Skip to content
Repos

blackcat

Markdown 97.9 KB1397 lines Opens in site

Directory Raw Download

Security Assessment of the DevPlace Web Application

An evidence-based refutation exercise against the claim that devplace.net is "unsafe in many ways", with a prioritised remediation programme for enterprise operation

Field Value
Engagement identifier record-20261110T004038Z
Client DevPlace, operator of devplace.net
Target https://devplace.net and the literal addresses it resolves to
Classification Client confidential
Report version 1.0.1 (final)
Report date 2026-11-10 (UTC)
Author role Principal consultant, application security
Methodology ./.pentest.md, phases P0 to P6, evidence contract of section 0.4
Assessment window 2026-11-10T00:40Z to 2026-11-10T23:59Z
Report status Issued for client action

Document control

Version history

Version Date (UTC) Author role Change
0.1 2026-11-10 Principal consultant Premise, scope and rules of engagement fixed before the first packet
0.5 2026-11-10 Principal consultant Reconnaissance and enumeration chapters; findings drafted from evidence
0.9 2026-11-10 Principal consultant Access control, injection and session chapters; refutation register completed
1.0 2026-11-10 Principal consultant Risk register, roadmap, retest plan and appendices; consistency pass
1.0.1 2026-11-10 Principal consultant Cross-reference, table and link corrections after internal review; no change to a finding or a score

Distribution list

Recipient Role Copy
DevPlace engineering lead Technical owner of the application Full report and evidence corpus
DevPlace product owner Decision-maker for the launch gate Full report
DevPlace operations Owner of DNS, TLS and host configuration The scope, findings and roadmap chapters, plus the DNS and TLS evidence

Handling notes

This document is client confidential. It contains reproducible descriptions of exploitable
weaknesses and must not be circulated outside the recipient list without the client's
written consent. It contains no live credential: session cookies, API keys, passwords and
recovery tokens are redacted as [REDACTED]. The two synthetic accounts used generated
credentials that were held only in the operator's scratch directory, which is purged at
closeout; no password or key is reproduced in this report or in any evidence file. Evidence
files are referenced by relative path and are stored under
./.record-20261110T004038Z/files/.

The assessment was performed against a production system that serves real users. The rules
of engagement therefore restricted interaction to read-only requests plus the minimum
synthetic state needed to prove a class. No availability test, no destructive action and no
bulk read of personal data was performed. The scope chapter states the resulting limitations plainly; the appendices state how the
client can reproduce every result.

Executive summary

The decision. DevPlace intends to present devplace.net to an enterprise customer as safe
to operate. This assessment was commissioned because an unnamed expert called the platform
"unsafe in many ways" without naming one. The evidence supports a narrower answer than either
position: the controls that separate users from each other and from administrators hold, and
the weaknesses that remain are in configuration, lifecycle policy and operational hardening.

No authentication bypass, cross-user data access, injection or infrastructure compromise was
reproduced. Five medium-severity issues must close before an enterprise security statement can
be signed.

Headline risk. The most consequential weakness is the combination of unbounded
credential guessing
, a six-character password minimum and registration that neither
verifies the mailbox nor limits account creation
. Separately, the application publishes its
complete API contract, including 147 administrative operations, and an XML-RPC
introspection interface that documents 379 methods with their required roles
. Neither
disclosure grants access, but together they remove the reconnaissance cost that normally
protects an administrative surface. An attacker does not have to discover what DevPlace
exposes; the application tells them, in machine-readable form, and then does not slow them
down when they try passwords.

The claim under test. "Unsafe in many ways" is directionally true as accumulated hygiene
debt - fifteen weaknesses across three severity bands, none above Medium - and false in the
sense that matters to an enterprise buyer, because the authorisation model was tested in eight
object classes and held in all eight. Confirmed and refuted hypotheses are recorded with equal
rigour, so the client can defend both halves of the statement.

Top three actions. First, remove /openapi.json, /docs and XML-RPC introspection from
anonymous reach, or replace them with a curated public contract: one day of work, no functional
loss, and a precondition for the enterprise conversation. Second, add server-side rate limiting
and progressive lockout to every authentication interface and raise the password minimum to
twelve characters with breach screening: two to three days, and it closes the only path found
from anonymous client to account takeover. Third, require mailbox verification before an
account can vote, post, message or spend AI quota, and remove the "Email already registered"
oracle: three to five days, and it stops automated account proliferation and targeted
phishing. The remaining findings are Low or Informational and belong in the same release train
rather than a separate project. The remediation roadmap sequences all fifteen with dependencies and a definition of done;
the verification and retest plan gives the acceptance test for each.

Scope, assumptions, constraints and limitations

Scope

The assessment covered one web application, its two literal addresses, and the deployment
configuration observable from them.

Asset Type In scope Depth
devplace.net Web application (apex) Yes Full: authentication, session, authorisation, injection, file handling, business logic, API, headers, disclosure, deployment
www.devplace.net Web application (alias) Yes Reconnaissance only; confirmed as a CNAME to the apex with identical content
95.216.15.238 IPv4 address Yes Enumeration: bounded TCP connect scan and virtual-host behaviour
2a01:4f8:222:2c45::2 IPv6 address Yes Enumeration: confirmed as the same host
All other hostnames under devplace.net Web No Resolved only; never contacted, because the client's authority statement covers the application, not an unbounded estate
*.pravda.education and *.tunnel.pravda.education Third party No Referenced by a CSP directive only; never contacted

The scope register, with the reasoning for each row, is at
./.record-20261110T004038Z/files/00-legal/scope.tsv. The rules of engagement are at
./.record-20261110T004038Z/files/00-legal/roe.md.

Authority and its limits

The client's engagement brief states that the application is to be assessed and that the
expert's claim is to be tested. No countersigned statement of work, authorisation letter,
non-disclosure agreement or data-processing agreement was supplied. This is recorded rather
than glossed over, because it changes what a professional team may do: the assessment was
therefore conducted read-only by default, with state changes limited to two synthetic
accounts and the objects needed to test object-level authorisation. The full inventory of
those changes, with identifiers, is the cleanup ledger at
./.record-20261110T004038Z/files/04-impact/cleanup-ledger.md. Two synthetic
accounts, two posts, one private project, four attachments and one follow edge remain on the
system; all content is inert, carries an ENGSEED marker and can be removed by the client in
minutes.

Assumptions

  1. The deployment examined is the deployment the client intends to operate. No staging system
    was in scope, and no evidence suggests that the production configuration differs from what
    a release candidate would use.
  2. The published API contract is authoritative for endpoint coverage. Where the schema and
    the running application disagreed, the application was treated as the truth.
  3. The two synthetic accounts represent the user role. No administrative account was
    available, so administrative behaviour was tested only from the outside, by attempting to
    reach administrative operations as an anonymous client and as an ordinary user.
  4. A finding is a statement about this deployment on this date, not a statement about the
    software in general.

Constraints

Constraint Consequence for the assessment
Production system with real users No destructive test, no availability test, no bulk read of personal data, no notification fan-out
No signed authorisation Read-only default; two synthetic accounts; no R2 or R3 action under the methodology's blast-radius scale
No mailbox controlled by the engagement Registration and password-reset flows judged by server-side effects; the delivered reset link could not be inspected
Single shared host Mail and SSH services on the same address were identified but not touched, because their ownership and tenant population are unknown
3000-request budget, 5 requests per second Coverage prioritised towards authorisation, authentication and disclosure rather than breadth-first fuzzing
One operator session Coverage is declared explicitly; absence of a finding is never reported as absence of the weakness

Explicit limitations

The following were not tested and must not be inferred as sound:

  • Administrative functions from an administrator session. Every administrative route was
    probed from outside and refused; the behaviour of those functions once authorised, including
    their own object-level checks, audit logging and input handling, is untested.
  • Container and workspace execution. The product offers container hosting and a workspace
    editor. Creating a container is an administrative or quota-bearing action; the isolation of
    the runtime, the container escape surface and the workspace editor's file handling were not
    exercised.
  • AI gateway behaviour under adversarial prompts. The assistant, its tool use, its system
    prompt and its outbound request primitive were not exercised, both because a call spends the
    operator's provider credit and because prompt injection requires a controlled model endpoint
    to be judged fairly. Guest access to the assistant is recorded as an exposure, unconfirmed.
  • Mail delivery paths. Password reset, email confirmation and notification delivery could
    not be observed end to end. The server-side request handling was tested; the message content
    and the link host were not.
  • Denial of service, load behaviour and resource exhaustion. Out of scope by the rules of
    engagement.
  • Third-party integrations other than by their observable interface: GIPHY, Telegram,
    push notifications, the node donation network and the federation peer protocol.
  • Supply chain and dependency vulnerabilities. No software composition analysis was
    performed against the application's own dependency tree.

Methodology

Standard and phase model

The assessment followed the client's named methodology, ./.pentest.md, phase by phase, and
applied its evidence contract: an action without an evidence record is treated as an action
that did not happen and may not appear in this report. The phases and their exit gates were:

Phase Question answered Gate Outcome
P0 What is being tested, for whom, within which limits, and what does success look like? G0 Premise, scope, rules of engagement, threat model and twenty falsifiable hypotheses fixed in writing before the first request
P1 What does the world already know about the target, with no packets to it? G1 DNS, WHOIS, certificate transparency, TLS metadata and published documents collected
P2 What is alive, what does it run, what does it expose? G2 Host inventory, 175-port connect scan, virtual-host behaviour, published contract, 209-operation unauthenticated matrix
P3 Which weakness classes exist here, proven, with a control for each claim? G3 Authentication, session, authorisation, injection, file handling, business logic, disclosure and configuration tested class by class
P4 What does an attacker with these weaknesses actually achieve, in what order? G4 Chains constructed and graded as demonstrated or plausible; no chain reached a critical outcome
P5 How far, how much data, what detection, inside the agreed blast radius? G5 Impact bounded to synthetic accounts; no third-party data read; cleanup ledger completed
P6 What does the reader do on Monday, in what order, and how is it proven? G6 This report, the risk register, the roadmap and the retest plan

Coverage model

Coverage is stated per class and per asset, not as a feeling. The unit of coverage is the
tested operation: an endpoint, a parameter, a header or a state transition for which a
request and a control exist in the evidence corpus.

Class Coverage on devplace.net Method Result
Authentication Full for anonymous and user roles Signup, login, logout, token issuance, reset request, fixation, timing, lockout arithmetic Four findings, two refutations
Session management Full Cookie attributes, rotation, invalidation, concurrency, entropy One finding, two refutations
Authorisation, horizontal Eight object classes Two synthetic identities, owner-positive controls, identifier substitution No confirmed defect; eight controls recorded
Authorisation, vertical Administrative surface, 147 operations Anonymous and ordinary-user attempts, REST and XML-RPC, including system.multicall No confirmed defect; three refutations
Injection Server-side and client-side, sampled SQL markers, XML external entities, stored and reflected markup, SVG seed injection, header injection No confirmed defect; four refutations
File handling Upload, storage, retrieval, naming Extension allow-list, content type, disposition, traversal-shaped names, access control No confirmed defect; two refutations
Business logic Registration, profile, project privacy, federation export, quotas State comparison before and after privileged fields; privacy toggles; export scope No confirmed defect; two refutations
Cryptography and transport TLS, certificate, HSTS, cookie flags Protocol negotiation, certificate chain, header matrix One Low finding
API behaviour 209 GET operations unauthenticated; write operations sampled Schema-driven matrix, method matrix, error handling Two Medium findings
Security headers Seven response classes Header capture per class One Low finding
Information disclosure Documents, scripts, error pages, introspection Published files, JS inventory, error bodies, RPC introspection Three findings
Deployment configuration Ports, virtual hosts, DNS, mail authentication Connect scan, Host header behaviour, DNS records Two findings
Denial of service Not tested Out of scope by the rules of engagement Declared
Container runtime Not tested Requires an administrative or quota-bearing action Declared
AI gateway abuse Partially tested Session and quota surface only One unconfirmed finding

Tools

The assessment used a deliberately small toolchain, because a production target rewards
precision over volume and because every tool added to a report must be reproducible by the
client.

Tool Version observed Use
curl 8.18.0 (OpenSSL 3.5.5) All HTTP interaction; raw request and response capture
openssl s_client 3.5.5 Certificate inspection, protocol negotiation
dig BIND utilities DNS inventory, resolution of certificate transparency names
whois standard client Registration age, registrar, status
python3 3.14.4 Deterministic request matrices, rate limiting, JSON and XML parsing
External data crt.sh, Cert Spotter Certificate transparency enumeration

No commercial scanner was used. This is a deliberate methodological choice: a scanner reports
signatures, and the weaknesses that matter in a bespoke application are missing authorisation
checks, state machines that trust the client and trust boundaries that nobody documented. The
matrix in ./.record-20261110T004038Z/scratch/matrix2.py is about seventy lines of Python and is reproduced in the command
corpus in Appendix B, so the client can rerun the same 209 requests and compare.

Rate discipline and blast radius

Every request was sequential or limited to four concurrent connections, at a ceiling of five
requests per second. No test produced a 5xx storm; the single 5xx response from the target was a
deliberate one-request probe recorded in
E-29. The total request volume for
the engagement is estimated at approximately 600 HTTP requests and 175 connection attempts,
well inside the 3000-request budget, and no request was retried in a loop. The engagement never reached blast-radius class
R2: no state-changing action outside the synthetic accounts was attempted, and every
administrative request was a read.

Evidence contract

Each evidence record carries the engagement identifier, the UTC start and end time, the
verbatim command, the exit code and the unedited combined output. Thirty-nine records exist, indexed
at ./.record-20261110T004038Z/files/evidence-index.tsv. The journal at
./.record-20261110T004038Z/logs/journal.md is the append-only audit trail: one line per action,
with the timestamp, the evidence path, the action, the return code and the first line of
output. Claims in this report cite an evidence identifier, and every identifier resolves to a
file in the corpus.

Findings

Findings are ordered by severity, then by the ease with which an anonymous attacker can
reach them. Each carries a stable identifier, a severity, a CVSS v3.1 vector and score where
the weakness is technical, the affected component, the evidence that supports it, the
technical description, a reproduction that a competent engineer can follow, the business
impact in the client's terms, the remediation and the residual risk that remains after that
remediation. Severity is assigned to the weakness as observed in this deployment, not to the
class in the abstract; where the two differ, the text says so.

F-01 - The complete API contract, including 147 administrative operations, is published to anonymous clients

Field Value
Severity Medium
CVSS v3.1 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N - 5.3
Affected component /openapi.json, /docs, /docs/index.html, /redoc (schema and interactive documentation)
Evidence E-06, E-08
Status Confirmed

Technical description. The application publishes an OpenAPI 3.1.0 document at
/openapi.json, 230,982 bytes, without authentication. It describes 453 paths and 519
operations, of which 147 are under /admin and 209 are GET. The document contains no
securitySchemes object and no per-operation security block, so it cannot tell a reader
which operations require a session - but it does tell a reader every operation that exists,
every path parameter, every request body shape and every response code. The interactive
Swagger UI is served at /docs and redirects to /docs/index.html. A control request to a
non-existent path returns 404 with a 9,358-byte error page, confirming that the schema
response is a real document and not a catch-all.

Reproduction.

curl -sS https://devplace.net/openapi.json | jq '{openapi, paths: (.paths|length)}'
curl -sS https://devplace.net/openapi.json | jq -r '.paths | keys[]' | grep '^/admin' | wc -l
curl -sS -o /dev/null -w '%{http_code}\n' https://devplace.net/this-path-does-not-exist-8f3a2b

The first command returns {"openapi":"3.1.0","paths":453}; the second returns 147; the
third returns 404, which is the control.

Business impact. The document removes the reconnaissance phase from an attack against the
administrative surface. An attacker does not need to discover /admin/backups/{uid}/download
or /admin/gateway/providers/{id}/edit; the application names them, describes their
parameters and states their response codes. In an application with a robust authorisation
layer, as this one has, the immediate impact is limited to information disclosure. The
secondary impact is reputational and commercial: an enterprise reviewer who opens
/openapi.json sees an administrative API with no declared authentication scheme, and draws
the reasonable conclusion that the security model is undocumented.

Remediation. Choose one of two strategies and apply it consistently. Either publish a
curated contract that contains only the public operations, generated from an allow-list and
served from a static file, or keep the full contract behind authentication and serve the
public subset at a separate path. Disable the interactive documentation in production or
protect it with the same session check as the administrative routes. If the full contract is
retained for internal use, add a securitySchemes definition and per-operation security
requirements so that the document itself becomes a security artefact rather than a map for
attackers.

Residual risk. Low. A determined attacker can still enumerate routes by other means, but
the cost rises from one request to a sustained campaign, and the administrative naming
convention stops being public.

F-02 - XML-RPC introspection publishes 379 methods with their required roles and parameters

Field Value
Severity Medium
CVSS v3.1 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N - 5.3
Affected component /xmlrpc and /xmlrpc/{path} (XML-RPC bridge)
Evidence E-14, E-15
Status Confirmed

Technical description. The XML-RPC bridge answers system.listMethods without
credentials and returns 379 method names, including the complete admin.* family. It also
answers system.methodHelp, which returns a paragraph containing the REST route, the group,
the required role and every parameter with its location and type. The help text for
admin.analytics states, verbatim, "Site analytics - GET /admin/analytics, Group: Admin API,
Auth: admin", followed by the parameter list. The bridge also supports system.multicall,
which was tested with an ordinary user's key: the administrative call inside the batch still
returned fault 403, so the batch mechanism does not bypass authorisation. The disclosure is
therefore of the map, not of the territory.

Reproduction.

curl -sS -X POST https://devplace.net/xmlrpc -H 'Content-Type: text/xml' \
  --data-binary '<?xml version="1.0"?><methodCall><methodName>system.listMethods</methodName><params></params></methodCall>' \
  | grep -c '<string>'
curl -sS -X POST https://devplace.net/xmlrpc -H 'Content-Type: text/xml' \
  --data-binary '<?xml version="1.0"?><methodCall><methodName>system.methodHelp</methodName><params><param><value><string>admin.analytics</string></value></param></params></methodCall>'

The first command returns 379; the second returns the route, group, role and parameters of
an administrative operation, to an unauthenticated caller.

Business impact. This is the same loss as F-01 through a second interface, and it is
worse in one respect: the help text states which role each method requires, so an attacker
can sort the 379 methods by privilege and attack only the boundary that matters, without
experimenting. It also confirms that the XML-RPC bridge is a full shadow of the REST API,
which doubles the surface that must be kept in step with any authorisation change.

Remediation. Disable system.listMethods, system.methodHelp and system.methodSignature
for anonymous callers, or remove introspection entirely in production. If the bridge is
required for integrations, keep the introspection methods but require an authenticated
session for them, and return only the methods that session's role may call.

Residual risk. Low, conditional on the authorisation layer remaining correct. The bridge
must be included in every future authorisation test; a second interface that mirrors the
first is a second place for a check to be forgotten.

F-03 - The login endpoint has no rate limit and no account lockout

Field Value
Severity Medium
CVSS v3.1 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N - 5.3
Affected component POST /auth/login, POST /auth/token, POST /api/users/auth-token, POST /xmlrpc with HTTP Basic
Evidence E-19, E-34
Status Confirmed

Technical description. Ten consecutive failed authentications against one synthetic
account returned HTTP 200 with the ordinary "Invalid email or password" page each time. The
eleventh request, carrying the correct password, returned 302 to /feed and issued a session.
No response carried Retry-After, X-RateLimit-* or any other throttling signal, and no
account-lock state was observable. The same login is reachable through four interfaces -
the HTML form, /auth/token, /api/users/auth-token and the XML-RPC bridge's HTTP Basic
mode - so a limit applied to the form alone would not cover the class. The absence of
enumeration at login (F-04 is a registration oracle, not a login oracle) means an attacker
does not learn which addresses are valid from this endpoint; they can nevertheless guess
passwords against addresses obtained elsewhere, such as the registration oracle or the public
profile directory.

Reproduction.

for i in $(seq 1 10); do
  curl -sS -o /dev/null -w '%{http_code}\n' -X POST https://devplace.net/auth/login \
    --data-urlencode 'email=KNOWN_ACCOUNT' --data-urlencode 'password=wrong-password'
done
curl -sS -o /dev/null -w '%{http_code} %{redirect_url}\n' -X POST https://devplace.net/auth/login \
  --data-urlencode 'email=KNOWN_ACCOUNT' --data-urlencode 'password=CORRECT_PASSWORD'

The first loop prints 200 ten times; the second command prints 302 and the feed URL.

Business impact. An attacker with a list of addresses and a list of common passwords can
test the pair space at the speed the server allows, indefinitely. The practical ceiling is
the password policy, and F-06 records that the policy permits six characters. The combination
is the only path the assessment found from an anonymous client to account takeover, and it is
also the mechanism by which a credential-stuffing campaign against a breached developer
database would succeed against this site. The absence of a limit also removes the signal that
would let the operator detect such a campaign.

Remediation. Apply three controls together, because each alone is weak. First, a
per-account and per-source-address rate limit on every authentication interface, expressed as
a token bucket with a documented ceiling and a 429 response carrying Retry-After. Second,
progressive delay or lockout after repeated failures, with an unlock path that does not create
a denial-of-service lever against a legitimate user. Third, a breach-list check at
registration and at password change, so that the passwords most likely to be guessed are
rejected before they are stored. Instrument failed authentications per account and per
address, and alert on a rate that exceeds the baseline.

Residual risk. Medium-low. Rate limiting reduces the guessing rate but does not eliminate
it; the residual risk is carried by the password policy and by the breach-list check.

F-04 - Registration neither verifies mailbox ownership nor limits account creation, and discloses whether an address is already registered

Field Value
Severity Medium
CVSS v3.1 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N - 5.3
Affected component POST /auth/signup, GET /auth/signup
Evidence E-10, E-11
Status Confirmed

Technical description. A registration request with a username, an address in a reserved
domain, a password, a birth date and a terms checkbox returns 302 to /feed and issues a
working session immediately. No confirmation message is required, no mailbox round trip
occurs, and no challenge is presented. A second request that reuses an existing address
returns HTTP 200 with the field-level message "Email already registered"; a request that reuses
an existing username returns "Username already taken". The two responses differ from a
successful registration in status and body, so the endpoint is a reliable oracle for both
identifiers. Two accounts were created during the assessment in under one second each, without
any verification step.

Reproduction.

curl -sS -o /dev/null -w '%{http_code} %{redirect_url}\n' -X POST https://devplace.net/auth/signup \
  --data-urlencode 'username=unique-name' --data-urlencode 'email=unique@example.com' \
  --data-urlencode 'password=TwelveCharPassw0rd' --data-urlencode 'confirm_password=TwelveCharPassw0rd' \
  --data-urlencode 'birth_date=1990-01-01' --data-urlencode 'accept_terms=1'
curl -sS -X POST https://devplace.net/auth/signup \
  --data-urlencode 'username=another-name' --data-urlencode 'email=unique@example.com' \
  --data-urlencode 'password=TwelveCharPassw0rd' --data-urlencode 'confirm_password=TwelveCharPassw0rd' \
  --data-urlencode 'birth_date=1990-01-01' --data-urlencode 'accept_terms=1' | grep -o 'Email already registered'

The first command returns 302 and /feed; the second prints Email already registered.

Business impact. Three consequences compound. An attacker can build a list of valid
addresses at machine speed, which converts a generic phishing campaign into a targeted one
against people who are known to hold an account here. An attacker can create accounts in
bulk, which matters because accounts can vote, comment, follow, message and consume AI quota;
the product's social signals and its AI spend are both exposed to Sybil behaviour. Finally,
because no mailbox is verified, an account can be registered against an address the registrant
does not control, which is the first step in impersonation and in the account-recovery
confusion described in the methodology's authentication chapter.

Remediation. Send a confirmation link to the address and hold the account in an
unverified state until it is followed; restrict voting, posting, messaging, following and AI
quota to verified accounts. Make the registration response uniform: accept the request, return
the same page with "Check your mailbox", and send either a confirmation message or, for an
address that already exists, a "someone tried to register with your address" notice. This
removes the oracle without degrading the user experience. Add a per-address and per-network
creation limit, and a challenge on the registration form once the limit is approached.

Residual risk. Low. Address enumeration through the recovery flow is already generic
(the reset request was tested separately and does not leak, see
E-20), so closing registration closes the
practical oracle.

F-05 - The domain publishes no SPF, no DMARC and no CAA record, and the zone is unsigned

Field Value
Severity Medium
CVSS v3.1 CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:N - 5.4
Affected component DNS zone devplace.net (Hostinger dns-parking.com nameservers)
Evidence E-01, E-05
Status Confirmed

Technical description. The zone publishes A and AAAA records, a Google site-verification
TXT record and an SOA. It publishes no MX record, no SPF TXT record, no DMARC record at
_dmarc, no CAA record and no DNSSEC delegation. Twenty-one hostnames appear in certificate
transparency, including jenkins, grafana, portainer, staging, mail, webmail,
cpanel and autodiscover; all of them resolve to the single in-scope address, and the
server answers an unknown Host header with a bare 404, so the historical administrative
names are no longer served. The reverse record for the address is devplace.pravda.education.

Reproduction.

dig +short TXT devplace.net
dig +short TXT _dmarc.devplace.net
dig +short CAA devplace.net
dig +short MX devplace.net
dig +short DS devplace.net

Every command returns empty except the TXT query, which returns only the Google verification
string.

Business impact. A domain with no SPF and no DMARC can be used as the envelope sender for
mail that claims to come from DevPlace, and receiving systems have no published policy to
quarantine it. For a platform that sends notifications, password resets and marketing mail,
this is a phishing enabler against the platform's own users, and it undermines the
deliverability of the legitimate mail the platform will need at enterprise scale. No CAA
record means any certificate authority may issue for the domain, which widens the window for a
mis-issuance to be exploited. The absence of DNSSEC is a lesser issue but is part of the same
zone-hardening task.

Remediation. Publish v=spf1 with the actual sending infrastructure and -all, publish a
DMARC record that starts at p=none with reporting and moves to p=reject once the reports
are clean, publish a CAA record naming the certificate authority actually used, and enable
DNSSEC with the registrar. Add DMARC reporting addresses that the operations team reads.

Residual risk. Low once SPF, DMARC at enforcement and CAA are published. The historical
hostnames remain visible in certificate transparency but are not served.

F-06 - The password policy permits six-character passwords with no other requirement

Field Value
Severity Low
CVSS v3.1 CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N - 3.7
Affected component POST /auth/signup, POST /auth/reset-password/{token}
Evidence E-09, E-10
Status Confirmed

Technical description. The signup form advertises "At least 6 characters" and the server
enforces exactly that. A submission with a one-character password returns HTTP 400 with the
field message "Password must be at least 6 characters"; a submission with a six-character
password satisfies the server and proceeds to account creation. No composition rule, no
breach-list check and no strength meter are enforced server-side. The same minimum applies to
the reset flow. There is no maximum-length rejection below 128 characters, which is adequate.

Reproduction.

curl -sS -X POST https://devplace.net/auth/signup \
  --data-urlencode 'username=x' --data-urlencode 'email=not-an-email' \
  --data-urlencode 'password=1' --data-urlencode 'confirm_password=1' \
  --data-urlencode 'birth_date=2030-01-01' --data-urlencode 'accept_terms=1' \
  | grep -o 'Password must be at least 6 characters'

The message is returned, which fixes the server-side minimum at six characters. The two
synthetic accounts created during the assessment used 24-character generated passwords and are
recorded in the cleanup ledger; no additional account was created to demonstrate this
finding.

Business impact. The policy lowers the cost of the guessing attack in F-03 and the cost of
credential stuffing. Six lowercase alphanumeric characters is a space of roughly two billion
combinations, which is small for an offline attack against a stolen hash and tractable online
if no rate limit exists. The weakness is rated Low in isolation and Medium in combination; it
is reported separately so that it is fixed even if the rate limit is deferred.

Remediation. Raise the minimum to twelve characters, reject the ten thousand most common
passwords and any password found in a breach corpus at registration and at change, and remove
composition rules that push users towards predictable substitutions. Apply the same rule to
the reset flow and to any administrative password change.

Residual risk. Low. Rate limiting (F-03) and breach screening together make the residual
guessing cost exceed the value of the account for all but high-value targets.

F-07 - The session cookie is issued without the Secure attribute

Field Value
Severity Low
CVSS v3.1 CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:N - 3.1
Affected component Set-Cookie: session on signup, login and every authenticated request
Evidence E-10, E-13
Status Confirmed

Technical description. The session cookie is issued as
session=[REDACTED]; HttpOnly; Max-Age=604800; Path=/; SameSite=lax. HttpOnly and
SameSite=Lax are present and correct; Secure is absent. The token is 64 characters from a
URL-safe alphabet, which is consistent with 384 bits of entropy and is not guessable. The
cookie is not rotated on privilege change, but no privilege change exists in the product for
an ordinary user. Logout invalidates the session server-side, and a session fixation attempt
was refused: a chosen pre-login value was replaced by a server-issued value and the chosen
value did not authenticate.

Reproduction.

curl -sS -D - -o /dev/null -X POST https://devplace.net/auth/login \
  --data-urlencode 'email=KNOWN_ACCOUNT' --data-urlencode 'password=CORRECT_PASSWORD' \
  | grep -i '^set-cookie'

The output contains HttpOnly, SameSite=lax and no Secure.

Business impact. Without Secure, the browser will attach the cookie to a plain-HTTP
request to the same host if one is ever made. The site redirects HTTP to HTTPS with a 308 and
carries a one-year HSTS policy with includeSubDomains, so a conforming browser that has seen
the HSTS header will not make that request. The residual exposure is to a browser that has not
yet received the header, to a non-browser client that follows a link, and to an active attacker
who can intercept the first plain-HTTP request before the redirect. The absence of the
__Host- prefix means a subdomain that is ever compromised could set a cookie for the parent
domain.

Remediation. Add Secure and rename the cookie to __Host-session with Path=/, no
Domain attribute and the same HttpOnly and SameSite values. The prefix forces the
browser to reject a cookie set by a subdomain or over HTTP.

Residual risk. Very low once Secure and the prefix are present.

F-08 - The Content Security Policy does not restrict script sources

Field Value
Severity Low
CVSS v3.1 CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:N - 3.1
Affected component Content-Security-Policy response header on every HTML response
Evidence E-37
Status Confirmed

Technical description. Every HTML response carries the same policy:
object-src 'none'; base-uri 'self'; frame-ancestors 'self' https://*.tunnel.pravda.education; form-action 'self'.
Those four directives are correct and useful. The policy contains no default-src, no
script-src, no style-src, no img-src and no connect-src, so script execution is
unrestricted: any injected inline script, any eval, and any third-party script host are
permitted. The same header set omits Permissions-Policy, Cross-Origin-Opener-Policy and
Cross-Origin-Resource-Policy. X-Content-Type-Options: nosniff, Referrer-Policy: strict-origin-when-cross-origin and Strict-Transport-Security: max-age=31536000; includeSubDomains are present and correct on every response class tested, including the
plain-HTTP redirect and the static asset path.

Reproduction.

for p in / /auth/login /feed /api/users/1 /admin; do
  printf '%s: ' "$p"
  curl -sS -D - -o /dev/null "https://devplace.net$p" | grep -i '^content-security-policy' || echo 'none'
done

Every line shows the same four-directive policy.

Business impact. The policy does not create a vulnerability; it removes a mitigation. The
application escapes user content correctly on the server (E-27),
and it loads DOMPurify for client-side rendering, so no execution path was found. The
consequence is that if any future rendering path is missed, the browser will not stop the
payload, and the API key material described in F-10 becomes reachable from script. In an
enterprise review, a policy without script-src is read as a control that exists on paper.

Remediation. Add a nonce-based script-src 'self' 'nonce-<per-response>' 'strict-dynamic'
and a default-src 'self'; add style-src 'self' 'unsafe-inline' only if the existing inline
styles require it, and migrate them to classes over time. Add frame-ancestors (already
present) and keep the existing object-src and base-uri. Report violations with
report-to for one release before enforcing, so that the policy does not break the workspace
and editor features.

Residual risk. Low. A restrictive policy reduces the impact of any future injection from
account takeover to a blocked request.

F-09 - Authenticated pages are served without cache directives

Field Value
Severity Low
CVSS v3.1 CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:N - 3.1
Affected component /feed, /messages, /notifications, /profile/{username} and other session-bearing HTML routes
Evidence E-34, E-37
Status Confirmed

Technical description. An authenticated request for /feed returns 200 with
Vary: Accept-Encoding and no Cache-Control, Pragma or Expires header. The
administrative routes, by contrast, return Cache-Control: no-store, no-cache, must-revalidate, max-age=0 on their 303 response. The application therefore knows the
directive exists and applies it to the administrative surface but not to the user-facing pages
that contain private messages, notifications and profile data.

Reproduction.

curl -sS -b session-cookie.txt -D - -o /dev/null https://devplace.net/feed | grep -i -E 'cache-control|pragma|expires'
curl -sS -b session-cookie.txt -D - -o /dev/null https://devplace.net/admin | grep -i -E 'cache-control|pragma|expires'

The first command prints nothing; the second prints the no-store directive.

Business impact. A shared cache, a corporate proxy, a service worker or a browser's
back-forward cache may retain a page that contains another user's private content. The
application serves directly from uvicorn with no shared proxy in front of it today, so the
practical exposure is the browser cache on a shared device and the history of a logged-out
session. Once a CDN is placed in front of the application - a likely step at enterprise
scale - the omission becomes a cross-user disclosure risk rather than a local one.

Remediation. Send Cache-Control: no-store on every response that is rendered for a
session, including the JSON API responses that carry user-specific data. Keep the immutable
cache directive on the hashed static assets, which is correct today.

Residual risk. Very low once the directive is applied consistently.

F-10 - The API key is embedded in the profile page as a DOM attribute

Field Value
Severity Low
CVSS v3.1 CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:N - 3.1
Affected component GET /profile/{username} for the authenticated owner; static script ApiKeyManager.js
Evidence E-39
Status Confirmed

Technical description. The owner's profile page contains
<code class="secret-value" data-api-key data-key="[REDACTED]" data-masked="true"> with a
CSS mask in place of the value. The reveal button does not fetch the key; it reads
dataset.key and swaps the text content. The key is therefore present in the page source, in
the browser's memory and in any DOM snapshot, even while it is visually masked. A control
confirmed that another user's profile page, and the anonymous view of the owner's page,
contain no key element, so this is not an object-level disclosure; it is an exposure to
anything that can read the page. The key is a UUIDv7, 36 characters, of which 48 bits are a
timestamp and the remainder random; it is adequate as a bearer credential but is not a
high-entropy secret in the sense that a 256-bit random token would be.

Reproduction.

curl -sS -b session-cookie.txt https://devplace.net/profile/OWN_USERNAME \
  | grep -o 'data-api-key[^>]*' | sed -E 's/data-key="[^"]*"/data-key="[REDACTED]"/'
curl -sS -b session-cookie.txt https://devplace.net/profile/OTHER_USER | grep -c 'data-key='

The first command prints the element; the second prints 0, which is the control.

Business impact. Any script that runs in the page can read the key, and the key
authenticates the full API, including every operation the session can perform, without the
HttpOnly protection that the session cookie enjoys. Combined with F-08 (no script-src), the
defence in depth that would normally contain a cross-site scripting defect is absent, so a
single rendering mistake escalates from session riding to durable API access. The exposure is
also reachable from a malicious browser extension or from a shared-device DOM inspection.

Remediation. Do not render the key into the page. Serve it from a dedicated endpoint that
requires a recent re-authentication, and display it only after an explicit action. Store the
key server-side as a hash, show it once at creation and on rotation, and treat the stored copy
as a credential rather than as display data. Lengthen the key to at least 128 random bits.

Residual risk. Low once the key is not in the DOM; the credential remains a bearer token
and should be rotatable, scoped and auditable.

F-11 - Guest clients are offered the AI assistant, with server-side provider spend

Field Value
Severity Low (unconfirmed)
CVSS v3.1 CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L - 3.7
Affected component /devii/session, /devii/usage, the assistant surface behind them
Evidence E-36
Status Unconfirmed

Technical description. An unauthenticated request to /devii/session returns
{"loggedIn":false,"username":"guest","enabled":true,"guestsEnabled":true} and
/devii/usage returns {"used_pct":0.0,"turns_today":0,"owner_kind":"guest"}. The application
therefore advertises a guest mode for the assistant, and meters usage against a guest owner.
Whether a guest turn actually reaches a provider and spends the operator's credit was not
tested, because a call would spend that credit and the assessment's rules of engagement
require the minimum state change. The finding is recorded as unconfirmed and must be
confirmed by the client before it is scheduled.

Reproduction.

curl -sS https://devplace.net/devii/session
curl -sS https://devplace.net/devii/usage

Both commands return the guest-enabled state without a cookie.

Business impact. If guest turns are served, the assistant is an unmetered spend channel
for anyone on the internet, and the quota model that protects the operator's provider account
is defeated by clearing a cookie. If guest turns are served from a local model or are refused
at the point of generation, the exposure is cosmetic. The distinction matters because the
same gateway is documented as holding provider keys.

Remediation. Confirm the intended guest behaviour. If guests may not spend provider
credit, enforce that at the gateway rather than at the interface, and return an explicit
refusal. If guests may spend, bind the guest quota to a server-side fingerprint with a low
ceiling, and alert on aggregate guest spend.

Residual risk. Unknown until the behaviour is confirmed; the control is cheap either way.

F-12 - State-changing operations are reachable by GET, including logout

Field Value
Severity Low
CVSS v3.1 CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:N - 3.1
Affected component GET /auth/logout, GET /notifications/open/{uid}, GET /profile/{username}/delete
Evidence E-13, E-30
Status Confirmed

Technical description. Logout is performed by a GET request, which invalidates the session
server-side and returns 302 to the landing page. Opening a notification is also a GET, which
marks it read. The account-deletion route has both a GET page and a POST action; only the GET
page was requested. SameSite=Lax on the session cookie means a cross-site GET does not carry
the cookie in modern browsers, so the practical cross-site request forgery risk is low, but
the pattern violates the method semantics that the rest of the application follows and makes
the endpoints reachable from a link, a prefetch or an image tag in a context where the cookie
is sent.

Reproduction.

curl -sS -b session-cookie.txt -D - -o /dev/null https://devplace.net/auth/logout | grep -i '^location'

The response is 302 with Location: /, and the cookie no longer authenticates.

Business impact. A logout link that fires on prefetch can end a session unexpectedly; a
notification that is marked read by a prefetch loses its unread state. The impact is limited
to integrity of small state, and no cross-user effect was found.

Remediation. Move logout and notification acknowledgement to POST with a CSRF token, and
keep the GET route as a confirmation page. Apply the same rule to any other GET route that
mutates state, and add a test that fails when a route with a mutating handler is registered
for GET.

Residual risk. Negligible.

F-13 - The application address also accepts SMTP, IMAP, IMAPS and SSH connections

Field Value
Severity Informational
CVSS v3.1 None assigned; the weakness is an exposure observation, not a scored vulnerability
Affected component 95.216.15.238, ports 22, 25, 143, 993
Evidence E-38
Status Confirmed (exposure); ownership of the mail service unconfirmed

Technical description. A bounded connect scan of 175 candidate TCP ports found six open:
22 (SSH), 25 (SMTP), 80 (HTTP), 143 (IMAP), 443 (HTTPS) and 993 (IMAPS). The application is
served on 80 and 443. No banner was retrieved from 22, 25, 143 or 993 and no protocol
interaction was attempted, because the ownership and tenant population of those services are
unknown and the rules of engagement forbid testing them. The DNS zone publishes no MX record,
so the mail service is not the domain's declared mail exchanger. The address is described by
the client as a shared Hetzner host.

Reproduction.

python3 ./.record-20261110T004038Z/scratch/portscan.py

The script prints the six open ports and the connect latency for each. It performs a TCP
connect and close, with no payload.

Business impact. An application host that also exposes mail and remote-shell services has
a larger patch surface and a larger credential surface than the application requires. If the
mail service belongs to the client, it is an unmanaged entry point into the same address that
serves the application; if it belongs to the hosting provider or another tenant, it is an
out-of-scope dependency that the client cannot patch and should not share an address with. The
observation is Informational because no weakness was demonstrated in those services; it
becomes a finding only if the client confirms ownership and exposes them deliberately.

Remediation. Confirm ownership of ports 25, 143 and 993. If they belong to the
application's host, move the application to an address that serves only 80 and 443, or restrict
the mail and SSH ports by firewall to the addresses that need them. If they belong to the
provider, record the shared-address dependency in the risk register and confirm with the
provider that the services are patched and monitored.

Residual risk. Depends on the ownership answer; the application itself is unaffected.

F-14 - An out-of-range numeric identifier produces an unhandled server error

Field Value
Severity Informational
CVSS v3.1 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:N - 0.0
Affected component GET /api/users/{user_id}
Evidence E-29, E-34
Status Confirmed

Technical description. A user identifier larger than a 64-bit integer
(/api/users/99999999999999999999) returns HTTP 500 with a 9,311-byte error page titled
"Server Error". The page is generic: it contains no traceback, no framework name, no file path
and no exception text, and the three occurrences of the string /app/ in it are part of the
apple-mobile-web-app-capable meta tag, not a filesystem path. Every other malformed
identifier tested - a non-numeric value, a negative value, a missing parameter, an
out-of-range rant and an out-of-range comment - returned a controlled 200 with a JSON error
body or a 404.

Reproduction.

curl -sS -o /dev/null -w '%{http_code}\n' https://devplace.net/api/users/99999999999999999999
curl -sS -o /dev/null -w '%{http_code}\n' https://devplace.net/api/users/abc

The first prints 500; the second prints 200 with a controlled "User not found" body.

Business impact. The defect is a robustness issue rather than a disclosure. It indicates
that the numeric path parameter is parsed without a range guard before it reaches the
database driver, and it produces an error response that monitoring will treat as a server
fault. An attacker can use it to generate noise in the operator's error budget, but not to
learn anything or to affect other users.

Remediation. Constrain the path parameter to a 64-bit signed integer at the framework
level, and return 404 for values outside the range. Add a regression test that asserts a
controlled response for the boundary values.

Residual risk. Negligible.

F-15 - robots.txt and the public documentation disclose internal and administrative routes

Field Value
Severity Informational
CVSS v3.1 None assigned; overlaps F-01 and F-02
Affected component /robots.txt, /docs/download.md, /docs/*.html, /sitemap.xml
Evidence E-06
Status Confirmed

Technical description. robots.txt disallows /admin/, /messages, /notifications,
/reports/mine, /uploads/ and /profile/*/delete, which is a directory of the sensitive
areas of the application. The site publishes a 668,491-byte documentation download at
/docs/download.md that describes administrative features, container environment keys, the
API key model and the workspace trust model, and a 1,865,698-byte sitemap that enumerates
public content. No .well-known/security.txt exists.

Reproduction.

curl -sS https://devplace.net/robots.txt
curl -sS -o /dev/null -w '%{http_code} %{size_download}\n' https://devplace.net/docs/download.md
curl -sS -o /dev/null -w '%{http_code}\n' https://devplace.net/.well-known/security.txt

The first prints the disallow list; the second prints 200 668491; the third prints 404.

Business impact. The disclosure duplicates, in weaker form, what F-01 and F-02 already
provide. Its independent value is to confirm to a casual attacker that an administrative
console exists and where it lives. The documentation is legitimately public - it is the
product manual - but it describes administrative-only features and container environment
keys, which is more architectural detail than a public manual requires.

Remediation. Remove the administrative entries from robots.txt and rely on
authentication rather than obscurity; a Disallow line is an advertisement. Review the
public documentation for administrative implementation detail and move it behind
authentication. Publish /.well-known/security.txt with a contact address and a disclosure
policy.

Residual risk. Negligible once F-01 and F-02 are closed.

Risk register

The register is the single table of record. Severity is the finding's assigned band; score is
the CVSS v3.1 base score where one applies. "Fix priority" is owner-agnostic: it says what to
do first, not who should do it. Status is Open for every finding in this issue, because no
remediation has yet been verified.

ID Finding Severity Score Asset Status Fix priority
F-01 Full API contract published anonymously, including 147 administrative operations Medium 5.3 API documentation surface Open P1
F-02 XML-RPC introspection discloses 379 methods with roles and parameters Medium 5.3 XML-RPC bridge Open P1
F-03 No rate limit or lockout on authentication Medium 5.3 Authentication endpoints Open P1
F-04 No mailbox verification, unlimited account creation, registration oracle Medium 5.3 Registration Open P1
F-05 No SPF, DMARC, CAA or DNSSEC for the domain Medium 5.4 DNS zone Open P1
F-06 Six-character password minimum, no breach screening Low 3.7 Registration, reset Open P1
F-07 Session cookie issued without Secure Low 3.1 Session management Open P2
F-08 CSP has no script-src or default-src; no Permissions-Policy Low 3.1 Every HTML response Open P2
F-09 Authenticated pages lack cache directives Low 3.1 Session-bearing HTML Open P3
F-10 API key embedded in the owner's profile DOM Low 3.1 Profile page, API keys Open P2
F-11 Guest clients offered the AI assistant with server-side spend (unconfirmed) Low 3.7 Devii assistant Open P2
F-12 State-changing GET routes, including logout Low 3.1 Logout, notifications Open P3
F-13 SMTP, IMAP, IMAPS and SSH open on the application address Informational 0.0 Host 95.216.15.238 Open P3
F-14 Out-of-range identifier returns an unhandled 500 Informational 0.0 /api/users/{id} Open P3
F-15 robots.txt and public docs disclose internal routes and admin detail Informational 0.0 Published documents Open P3

Distribution

Band Count Findings
Critical 0 None
High 0 None
Medium 5 F-01, F-02, F-03, F-04, F-05
Low 7 F-06, F-07, F-08, F-09, F-10, F-11, F-12
Informational 3 F-13, F-14, F-15

What the register does not contain

The register is not a statement that the application is free of high-severity weaknesses. It
is a statement that none was reproduced within the declared coverage. Two classes carry the
largest unexamined risk and are declared in the scope limitations: the behaviour of administrative
functions once authorised, and the isolation of the container and workspace runtime. A
high-severity defect in either would not have been visible to this assessment, and the client
should commission a scoped follow-up before making a statement about those areas.

Attack narrative

The narrative distinguishes demonstrated chains, which were executed end to end within the
rules of engagement, from plausible chains, which are assembled from confirmed findings but
whose final step was not executed because it would have required a real victim, real data or a
destructive action. No chain reached a critical outcome. The value of the section is to show
the client why the individual Medium findings belong in one release train rather than three.

Chain 1 - Account enumeration to credential guessing to account takeover (demonstrated to step three)

This is the only chain the assessment carried to a point where the next step would have harmed
a real user.

  1. Enumerate. POST /auth/signup with an address returns "Email already registered" when
    the address exists and 302 to /feed when it does not
    (E-11). The endpoint has no rate
    limit, so a list of candidate addresses can be classified at the speed the server allows.
    Demonstrated.
  2. Select. The public profile directory and the sitemap supply usernames in bulk, and the
    profile API returns a stable numeric identifier for each
    (E-08). Address
    candidates then come from the usual developer-community sources, or from the username itself
    where the pattern is predictable. Demonstrated for the username and identifier step; the
    address step depends on data the platform does not itself publish.
  3. Guess. POST /auth/login accepts an unlimited number of failures and does not lock the
    account: ten failures followed by the correct password returned 302 and a session
    (E-19). The password policy permits
    six characters (F-06). Demonstrated.

The next step - succeeding against a real account - was not attempted. The chain is
nevertheless the most important one in the report, because every step is cheap, none requires
a tool beyond curl, and the only control standing between step three and a takeover is the
password a user chose. The remediation that breaks the chain is the combination in F-03 and
F-04: rate limiting, verification and a stronger policy.

Chain 2 - Public contract to targeted administrative attack (plausible)

  1. GET /openapi.json returns 453 paths, 147 of them administrative
    (E-06). Demonstrated.
  2. system.methodHelp on the XML-RPC bridge returns the required role and the parameter list
    for each of 379 methods, including the administrative family
    (E-15). Demonstrated.
  3. An attacker sorts the methods by role, selects the administrative read operations that
    return the most data, and probes them for a missing check. Not demonstrated: every
    administrative route tested refused an anonymous client and an ordinary user, through REST
    (303 to the login page, 403 from the JSON API), through XML-RPC (fault 403) and through
    system.multicall (fault 403), as recorded in
    E-25 and
    E-36.

The chain is plausible rather than demonstrated because its final step depends on a defect
that this assessment did not find. Its importance is that the cost of the first two steps is
two requests, so any future authorisation mistake anywhere in the 147 administrative
operations is immediately reachable by anyone, with no discovery phase and no warning. Closing
F-01 and F-02 converts a one-request attack into a campaign that the operator can detect.

Chain 3 - Domain spoofing to credential phishing (plausible)

  1. The zone publishes no SPF and no DMARC record
    (E-01). Demonstrated.
  2. An attacker sends mail that claims to be from devplace.net to addresses harvested through
    Chain 1, pointing at a lookalike login page. Not demonstrated: sending mail to third
    parties is forbidden by the rules of engagement, and no message was sent.
  3. A recipient who reuses a password hands over credentials that the unlimited login endpoint
    accepts. Not demonstrated for the same reason.

The chain matters commercially because the platform's own notifications, password resets and
invitations are the messages its users are trained to trust. A domain that cannot be
distinguished from a spoof is a liability for every one of those messages.

What did not chain

The following were tested specifically to see whether they would compose into a more severe
outcome, and each held.

Attempted composition Result Evidence
Object identifier substitution across two accounts, six object classes Refused or indistinguishable from not-found in every class E-22, E-23, E-30, E-35
Private profile tab read by another user The tab is not rendered for a non-owner E-16, E-17
Ordinary user reaching the administrative surface by REST, XML-RPC or multicall Refused in all three E-25, E-36
Mass assignment of role, score, verification or API key through the profile update Fields ignored; state unchanged E-26
Stored markup in a post rendering as script for another user Escaped in HTML, meta tags and JSON-LD E-27
Reflected markup in search parameters Escaped E-33
SVG injection through the avatar seed Seed rejected with 404 E-28
Upload of active content, and traversal in the stored filename Extension refused; storage name generated; served as attachment E-24
XML external entity, and entity expansion in the RPC parser DTD-bearing documents rejected with 400 E-33
Host header injection into absolute URLs and the reset link The server refuses unknown hosts with a bare 404 and does not reflect the header E-32
Session fixation and post-logout replay Server-issued value replaces a chosen value; logout invalidates server-side E-13
CORS reflection with credentials No Access-Control-Allow-Origin header on any endpoint tested E-25
Federation export as a bulk data read 403 for an ordinary user on every kind E-31
Open redirect through the login next parameter Ignored; redirect always to the feed E-20

The pattern is consistent and worth stating plainly to the client: the application's
authorisation and output-encoding layers are its strongest controls, and they are stronger
than the surrounding operational posture. The defects in this report are concentrated where
those layers are not involved - in what the application publishes about itself, in the absence
of throttling, in domain configuration and in response headers.

Remediation roadmap

The roadmap is sequenced by dependency and by the decision it unblocks, not by severity alone.
Items in stage 1 are prerequisites for an enterprise security statement; stage 2 items belong
in the same quarter; stage 3 items are hygiene that can ride the normal release train.

Stage 1 - before the enterprise statement (target: 14 days)

# Item Findings Effort Depends on Definition of done
1.1 Replace the anonymous API contract with a curated public subset; protect the full contract and Swagger UI F-01 1 day None Anonymous GET /openapi.json and /docs return 401 or a curated document with no /admin path; the public subset is generated from an allow-list and reviewed at each release
1.2 Disable or authenticate XML-RPC introspection F-02 0.5 day None Anonymous system.listMethods returns a fault; an authenticated call returns only the caller's role-visible methods
1.3 Add rate limiting, progressive lockout and alerting to every authentication interface F-03 3 days Shared limiter for REST, form and XML-RPC The tenth consecutive failure on one account returns 429 with Retry-After; the limit is enforced through all four interfaces; a dashboard shows failures per account and per address
1.4 Require mailbox verification and remove the registration oracle F-04 4 days Mail delivery (F-05 SPF/DMARC for deliverability) A new account cannot vote, post, message, follow or spend AI quota before verification; duplicate registration returns the same page and status as a new one; a per-address creation limit is enforced
1.5 Raise the password policy and add breach screening F-06 1 day None Passwords below twelve characters are rejected server-side; a known-breached password is rejected at registration and at change; the reset flow applies the same rule
1.6 Publish SPF, DMARC and CAA; enable DNSSEC F-05 1 day Access to the DNS provider dig returns an SPF record ending in -all, a DMARC record, a CAA record naming the CA, and a DS record; DMARC moves to p=reject after two clean reporting weeks

Stage 2 - same quarter (target: 45 days)

# Item Findings Effort Depends on Definition of done
2.1 Add Secure and the __Host- prefix to the session cookie F-07 0.5 day None Every Set-Cookie for the session carries Secure, HttpOnly, SameSite=Lax and the __Host- prefix; a plain-HTTP request does not receive the cookie
2.2 Adopt a nonce-based Content Security Policy and add Permissions-Policy F-08 2 days Inventory of inline scripts and third-party origins The policy contains default-src 'self' and script-src with a per-response nonce; the browser console shows no violations on the landing, feed, profile, editor and admin pages
2.3 Stop rendering the API key into the DOM; rotate and lengthen keys F-10 2 days None No page source contains key material; the key is shown once at creation and on explicit re-authentication; new keys carry at least 128 random bits; old keys are rotated with a documented grace period
2.4 Confirm and, if necessary, restrict the mail and SSH services on the application address F-13 1 day (investigation) Provider confirmation Ownership is recorded; ports other than 80 and 443 are closed or firewalled to named addresses; the answer is written into the risk register
2.5 Confirm the guest AI behaviour and enforce the intended quota F-11 1 day None A guest turn either returns an explicit refusal or is metered against a server-side ceiling; aggregate guest spend is alerted

Stage 3 - next release train (target: 90 days)

# Item Findings Effort Depends on Definition of done
3.1 Send Cache-Control: no-store on every session-bearing response F-09 0.5 day None /feed, /messages, /notifications and /profile/{username} return no-store; static assets keep their immutable directive
3.2 Guard the numeric path parameters and return 404 for out-of-range values F-14 0.5 day None A boundary-value regression test passes; no malformed identifier produces a 5xx
3.3 Reduce the information in robots.txt and the public documentation; publish security.txt F-15 1 day Items 1.1 and 1.2 robots.txt contains no administrative path; the public manual carries no administrative implementation detail; /.well-known/security.txt returns 200 with a monitored contact
3.4 Move state-changing GET routes to POST with CSRF protection F-12 1 day None Logout and notification acknowledgement are POST-only and carry a CSRF token; a route-registration test fails on a mutating GET
3.5 Commission the two scoped follow-ups declared in the scope limitations Coverage limits 5 days each None An authorised administrator tests the administrative functions and the container runtime; the results are appended to this register

Sequencing rationale

Items 1.1 and 1.2 are first because they are hours of work, they remove the map of the
administrative surface, and they change what an enterprise reviewer sees on the first request.
Items 1.3 and 1.4 are next because together they are the only path from anonymous client to
account takeover that the assessment found, and because verification also closes the Sybil
exposure that the social and AI features carry. Item 1.6 is placed in stage 1 despite ranking below the
authentication items in direct exploitability, because the platform cannot send trustworthy
transactional mail without it,
and item 1.4 depends on that mail being deliverable. The stage 2 and stage 3 items are ordered
so that each can ship independently; none blocks another.

Verification and retest plan

Every acceptance criterion below is written so that the client can run it from a shell and
obtain a pass or fail without interpretation. The retest should be performed by a party other
than the implementer, against the production configuration, within thirty days of each stage's
completion. Findings are closed only when the criterion passes and the evidence is attached to
the ticket.

ID Acceptance criterion Command or procedure Pass condition
F-01 Anonymous clients cannot obtain the administrative contract curl -sS -o /dev/null -w '%{http_code}' https://devplace.net/openapi.json and grep -c '"/admin' on the body if 200 401, or a 200 document containing zero /admin paths
F-02 Anonymous introspection is refused curl -sS -X POST https://devplace.net/xmlrpc -H 'Content-Type: text/xml' --data-binary '<methodCall><methodName>system.listMethods</methodName></methodCall>' A fault response, or a method list containing no admin.* names
F-03 Authentication is throttled on every interface Eleven consecutive failures on one account, then a correct attempt, on the form, /auth/token, /api/users/auth-token and XML-RPC Basic At least one 429 with Retry-After before the eleventh attempt, on all four interfaces, and an alert raised in monitoring
F-04 Registration verifies the mailbox and does not leak Register a fresh address, then register an existing address from a different client The first account cannot vote, post, message or spend quota until verified; the second request returns the same status and body as the first, and a notice is sent to the existing address
F-05 Mail authentication and CAA are published dig +short TXT devplace.net, dig +short TXT _dmarc.devplace.net, dig +short CAA devplace.net, dig +short DS devplace.net SPF present and ending in -all; DMARC present; CAA present; DS present
F-06 Password policy is enforced server-side Submit a six-character password to signup and to the reset flow Both return a validation error; a known-breached twelve-character password is also rejected
F-07 Session cookie attributes are complete curl -sS -D - -o /dev/null -X POST https://devplace.net/auth/login --data-urlencode 'email=...' --data-urlencode 'password=...' \| grep -i set-cookie The header contains Secure, HttpOnly, SameSite=Lax and the __Host- prefix
F-08 The CSP restricts script sources curl -sS -D - -o /dev/null https://devplace.net/ \| grep -i content-security-policy The policy contains default-src and script-src with a nonce or a hash; no unsafe-inline on script-src
F-09 Session pages are not cacheable curl -sS -b cookie.txt -D - -o /dev/null https://devplace.net/feed \| grep -i cache-control no-store present on /feed, /messages, /notifications and /profile/{username}
F-10 No key material in the DOM curl -sS -b cookie.txt https://devplace.net/profile/OWN_USERNAME \| grep -c 'data-key=' 0; the key is obtainable only through an explicit re-authenticated action
F-11 Guest AI is refused or bounded curl -sS https://devplace.net/devii/session and a single guest turn against a staging instance Either guestsEnabled:false, or the turn is refused at the gateway, or the guest ceiling and alert are demonstrated
F-12 Mutating routes are POST-only curl -sS -o /dev/null -w '%{http_code}' https://devplace.net/auth/logout and the same for a notification 405 on GET; the POST route requires a CSRF token
F-13 Only application ports are reachable Rerun the bounded connect scan from Appendix B 80 and 443 open; 22, 25, 143 and 993 closed or firewalled, or the shared-address dependency is documented and accepted
F-14 Malformed identifiers are controlled curl -sS -o /dev/null -w '%{http_code}' https://devplace.net/api/users/99999999999999999999 404, or a controlled 400, never 5xx
F-15 Published files carry no administrative detail curl -sS https://devplace.net/robots.txt and curl -sS https://devplace.net/.well-known/security.txt No Disallow line names an administrative route; security.txt returns 200

Regression suite

Three tests should become permanent, because each guards a class that a future change could
silently break.

  1. The unauthenticated matrix. Replay all 209 documented GET operations without a cookie
    and assert that no operation that is not on the public allow-list returns 200. The script is
    reproduced in Appendix B and runs in under a minute at the agreed rate.
  2. The two-identity object matrix. For each object class with an owner, create one object
    per identity in a test environment and assert that the cross-identity request returns 403 or
    404. This is the only reliable defence against the regression that matters most.
  3. The administrative negative test. Assert that an ordinary user's session and API key
    receive 403 or a login redirect on a sample of administrative routes, through REST and
    through XML-RPC, including a system.multicall batch.

Closure criteria

A finding is closed when the acceptance criterion passes on production, the evidence is
attached to the ticket, and the regression test that covers the class is in the continuous
pipeline. A finding is not closed by a code review, by a configuration change that has not been
verified from outside, or by a compensating control that has not been documented in the risk
register.

Appendices

Appendix A - Evidence index

Every claim in this report resolves to one of the forty records below. Each file contains the
engagement identifier, the UTC start and end time, the verbatim command, the exit code and the
unedited combined output. The machine-readable index is at
./.record-20261110T004038Z/files/evidence-index.tsv.

ID Phase Content File
E-01 P1 DNS inventory: A, AAAA, NS, MX, TXT, CAA, SOA, DMARC 01-p1-dns-inventory.txt
E-02 P1 WHOIS, certificate, protocol negotiation, cipher 02-p1-whois-tls.txt
E-03 P1 First certificate transparency attempt, upstream 502 03-p1-crtsh.txt
E-04 P1 Certificate transparency enumeration, two sources 04-p1-ct-enumeration.txt
E-05 P1 Resolution of all twenty-one transparency names 05-p1-ct-name-resolution.txt
E-06 P1 Published documents: robots, sitemap, manifest, schema, docs 06-p1-published-documents.txt
E-07 P2 Unauthenticated matrix, first pass, redirects followed 07-p2-unauth-get-matrix.txt
E-08 P2 Unauthenticated matrix, 209 operations, redirects refused 08-p2-unauth-get-matrix-no-redirect.txt
E-09 P3 Signup and login validation without a body 09-p3-signup-validation-probe.txt
E-10 P3 Synthetic account A and its cookie attributes 10-p3-signup-account-a.txt
E-11 P3 Synthetic account B and the registration oracles 11-p3-signup-account-b-and-enumeration.txt
E-12 P3 Session lifecycle, first attempt with the wrong oracle 12-p3a-session-lifecycle.txt
E-13 P3 Session lifecycle with a valid oracle: logout, fixation, entropy 13-p3a-session-lifecycle-redo.txt
E-14 P3 XML-RPC introspection: 379 methods anonymously 14-p3-xmlrpc-introspection.txt
E-15 P3 XML-RPC method help and administrative calls 15-p3-xmlrpc-authz-probe.txt
E-16 P3 Private profile tab access control 16-p3b-profile-private-tab-authz.txt
E-17 P3 Private tab with a seeded notification event 17-p3b-notification-idor-with-seeded-event.txt
E-18 P3 Username-scoped profile writes 18-p3b-profile-write-idor-grouping.txt
E-19 P3 Login enumeration and lockout arithmetic 19-p3a-login-enumeration-and-lockout.txt
E-20 P3 Password reset behaviour and open-redirect handling 20-p3a-password-reset-and-open-redirect.txt
E-21 P3 Seeding of objects owned by account B 21-p3b-seed-objects-account-b.txt
E-22 P3 Post edit authorisation across identities 22-p3b-post-edit-idor.txt
E-23 P3 Attachment access control and static serving 23-p3c-upload-serving-and-access.txt
E-24 P3 Upload allow-list and filename handling 24-p3c-upload-active-content-and-filename.txt
E-25 P3 CORS and vertical authorisation 25-p3b-cors-and-vertical-authz.txt
E-26 P3 Mass assignment on the profile update 26-p3c-mass-assignment-profile-update.txt
E-27 P3 Stored markup in a post, rendered anonymously 27-p3c-stored-markup-probe.txt
E-28 P3 SVG avatar seed injection 28-p3c-avatar-svg-injection.txt
E-29 P3 Error handling, injection markers, traversal probes 29-p3c-error-handling-and-injection-probes.txt
E-30 P3 Notification open authorisation 30-p3b-notification-open-idor.txt
E-31 P3 Federation export authorisation, ten kinds 31-p3b-sync-export-scope.txt
E-32 P3 Host header injection and ingress traversal 32-p3c-host-header-injection.txt
E-33 P3 Reflected markup, token endpoints, XML parser 33-p3c-reflected-xss-and-token-endpoints.txt
E-34 P3 Error page content, cache and rate headers 34-p3c-error-page-and-cache-headers.txt
E-35 P3 Private project access control 35-p3b-private-project-access.txt
E-36 P3 Method matrix, multicall, query-string key, guest surface 36-p3b-method-and-auth-bypass-probes.txt
E-37 P3 Security header matrix across seven response classes 37-p3c-security-headers-matrix.txt
E-38 P2 Bounded connect scan of the in-scope address 38-p2-connect-scan-top200.txt
E-39 P3 API key material in the owner's profile DOM 39-p3c-api-key-dom-exposure.txt

Supporting artefacts that are not themselves evidence:

Artefact Path Purpose
Rules of engagement ./.record-20261110T004038Z/files/00-legal/roe.md Authority basis, limits, forbidden actions
Scope register ./.record-20261110T004038Z/files/00-legal/scope.tsv Every asset and its in-scope decision
Premise ./.record-20261110T004038Z/files/01-premise/premise.md The six questions, answered before the first packet
Threat model ./.record-20261110T004038Z/files/01-premise/threat-model.md Assets, actors, trust boundaries, shortest paths
Hypothesis register ./.record-20261110T004038Z/files/01-premise/hypotheses.tsv Twenty falsifiable claims and their verdicts
API inventory ./.record-20261110T004038Z/files/02-recon/api-inventory.tsv 519 operations extracted from the published contract
OpenAPI document as served ./.record-20261110T004038Z/files/02-recon/openapi.json The contract as an artefact of record
Cleanup ledger ./.record-20261110T004038Z/files/04-impact/cleanup-ledger.md Every state change, its identifier and disposition
Operator journal ./.record-20261110T004038Z/logs/journal.md Append-only audit trail, one line per action

Appendix B - Command corpus

The commands below are reproduced verbatim so that an independent team can repeat the work.
Placeholders in upper case must be replaced with values the client controls; no credential is
reproduced here.

  # P1: passive collection
dig +short A devplace.net; dig +short AAAA devplace.net; dig +short TXT devplace.net
dig +short TXT _dmarc.devplace.net; dig +short CAA devplace.net; dig +short MX devplace.net
whois devplace.net | egrep -i 'creation date|registrar|name server|status'
curl -sS -m 120 -A 'record-20261110T004038Z-assessment/1.0' 'https://crt.sh/?q=devplace.net&output=json'
echo | openssl s_client -connect devplace.net:443 -servername devplace.net 2>/dev/null \
  | openssl x509 -noout -subject -issuer -dates -ext subjectAltName

  # P2: enumeration
curl -sS -D - -o /dev/null https://devplace.net/
for p in /robots.txt /sitemap.xml /manifest.json /openapi.json /docs /favicon.ico; do
  curl -sS -o /dev/null -w "$p %{http_code} %{size_download} %{content_type}\n" "https://devplace.net$p"
done
python3 ./.record-20261110T004038Z/scratch/matrix2.py   # 209 documented GETs, 5 req/s, no redirects
python3 ./.record-20261110T004038Z/scratch/portscan.py  # 175 candidate ports, connect() only

  # P3: authentication and session
curl -sS -i -X POST https://devplace.net/auth/signup --data-urlencode 'username=NAME' \
  --data-urlencode 'email=ADDRESS' --data-urlencode 'password=PASSWORD' \
  --data-urlencode 'confirm_password=PASSWORD' --data-urlencode 'birth_date=1990-01-01' \
  --data-urlencode 'accept_terms=1'
curl -sS -D - -o /dev/null -X POST https://devplace.net/auth/login \
  --data-urlencode 'email=ADDRESS' --data-urlencode 'password=WRONG' | grep -i set-cookie
curl -sS -b COOKIE_JAR https://devplace.net/devii/session      # session oracle
curl -sS -b COOKIE_JAR -D - -o /dev/null https://devplace.net/auth/logout
curl -sS -b COOKIE_JAR https://devplace.net/devii/session      # must report loggedIn:false

  # P3: authorisation, two identities
curl -sS -b COOKIE_B -X POST https://devplace.net/posts/create \
  --data-urlencode 'title=T' --data-urlencode 'topic=devlog' --data-urlencode 'content=SEED'
curl -sS -b COOKIE_A -o /dev/null -w '%{http_code} %{redirect_url}\n' \
  -X POST https://devplace.net/posts/edit/POST_SLUG --data-urlencode 'content=ATTEMPT'
curl -sS -b COOKIE_B -o /dev/null -w '%{http_code}\n' https://devplace.net/projects/PRIVATE_SLUG/files
curl -sS -b COOKIE_A -o /dev/null -w '%{http_code}\n' https://devplace.net/projects/PRIVATE_SLUG/files
curl -sS -H "X-API-KEY: KEY_A" -o /dev/null -w '%{http_code}\n' https://devplace.net/admin/analytics
curl -sS -X POST https://devplace.net/xmlrpc -H 'Content-Type: text/xml' \
  --data-binary '<?xml version="1.0"?><methodCall><methodName>admin.analytics</methodName><params><param><value><struct></struct></value></param></params></methodCall>'

  # P3: injection and handling
curl -sS "https://devplace.net/feed?search=%22%3E%3Cimg%20src=x%20onerror=window.__rx%3D1%3E" \
  | grep -o -E 'value="[^"]*__rx[^"]*"'
curl -sS -X POST https://devplace.net/xmlrpc -H 'Content-Type: text/xml' \
  --data-binary '<?xml version="1.0"?><!DOCTYPE d [<!ENTITY m "X">]><methodCall><methodName>system.methodHelp</methodName><params><param><value><string>&m;</string></value></param></params></methodCall>'
curl -sS -H "X-API-KEY: KEY_A" -F 'file=@seed.txt;type=text/plain' https://devplace.net/uploads/upload
curl -sS -H "X-API-KEY: KEY_A" -F 'file=@seed.svg;type=application/octet-stream' https://devplace.net/uploads/upload

  # P3: headers and configuration
for p in / /auth/login /feed /api/users/1 /admin; do
  curl -sS -D - -o /dev/null "https://devplace.net$p" | grep -i -E 'content-security-policy|strict-transport|x-content-type|referrer-policy|cache-control'
done
curl -sS -H 'Host: unrelated.example' --resolve unrelated.example:443:95.216.15.238 -o /dev/null \
  -w '%{http_code}\n' https://unrelated.example/

Appendix C - Hypothesis register and verdicts

The register was written before the first request. Five hypotheses were confirmed, eleven were
refuted, three were confirmed only in part, and one could not be tested. Recording the refutations is as
important as recording the findings: it is what allows the client to say that a class was
tested and held, rather than that it was not looked at.

ID Hypothesis, abbreviated Verdict
H-01 The published schema is a complete inventory of operations Confirmed
H-02 A documented read returns non-public data anonymously Refuted
H-03 The administrative surface is reachable anonymously Refuted
H-04 The administrative surface is reachable by a low-privilege user Refuted
H-05 An object identifier is not bound to the session Refuted across six object classes
H-06 The session cookie lacks a protection attribute Confirmed: Secure absent, HttpOnly and SameSite present
H-07 A session survives logout Refuted
H-08 The login endpoint reveals whether an account exists Refuted at login, confirmed at registration
H-09 Authentication has no lockout or rate limit Confirmed
H-10 User markup reaches another browser unescaped Refuted in four rendering contexts
H-11 Security headers are incomplete in a way that changes exploitability Confirmed in part: no script policy; HSTS and nosniff correct
H-12 Errors disclose internals Refuted
H-13 Secrets are readable in public scripts or configuration Refuted, except key material in the owner's own DOM
H-14 Upload accepts active content or serves it as such Refuted
H-15 A server-side request primitive reaches internal addresses Not tested
H-16 Business logic trusts client-supplied privilege fields Refuted
H-17 Infrastructure interfaces are exposed publicly Confirmed in part: mail and SSH ports open; no debug interface
H-18 Transport security is weak Refuted
H-19 Public content is scrapeable in bulk Confirmed as a design property
H-20 "Unsafe in many ways" is substantially correct Confirmed in the weak sense: five Medium, seven Low, three Informational, no Critical or High

Appendix D - Glossary

Term Meaning in this report
Blast radius class The methodology's scale of test intrusiveness; R0 is passive, R1 is a single read, R2 and R3 require written approval. This engagement stayed at R1.
Control A request made in the same shape as the test, against a known-good case, so that a negative result can be distinguished from a broken test.
CVSS v3.1 The Common Vulnerability Scoring System, version 3.1. The vector and the base score are given for every technical finding.
Evidence record A file containing the timestamp, verbatim command, exit code and unedited output of one action.
IDOR Insecure direct object reference: an operation that accepts an object identifier from the client without binding it to the session.
OpenAPI The machine-readable API contract served at /openapi.json.
Premise The falsifiable statement the engagement tests; if it is refuted, the refutation is the finding.
Refuted A hypothesis for which the control showed the weakness absent, with the evidence recorded.
RPC Remote procedure call; here, the XML-RPC bridge at /xmlrpc that mirrors the REST API.
Session oracle An endpoint whose response states whether the caller is authenticated; /devii/session was used for this purpose.
Synthetic account An account created by the engagement, with generated credentials, used only to test authorisation.
XSS Cross-site scripting: injection of markup that executes in another user's browser.

Appendix E - References

The assessment follows the following standards and specifications by name; no external link
is reproduced because the client's copy of each is authoritative.

  1. OWASP Web Security Testing Guide, version 4.2 - test categories used for the coverage model.
  2. OWASP Application Security Verification Standard, version 4.0.3 - authentication, session and access-control requirements.
  3. OWASP Top Ten, 2021 - classification cross-reference for the risk register.
  4. FIRST CVSS v3.1 Specification Document - vector construction and scoring.
  5. NIST Special Publication 800-63B - authenticator and password policy guidance.
  6. RFC 7208 - Sender Policy Framework.
  7. RFC 7489 - Domain-based Message Authentication, Reporting and Conformance.
  8. RFC 8659 - DNS Certification Authority Authorization.
  9. RFC 6265 and the cookie-prefix specification - Secure, HttpOnly, SameSite and the __Host- prefix.
  10. CWE-307 (improper restriction of excessive authentication attempts), CWE-204 (observable response discrepancy), CWE-614 (sensitive cookie without Secure), CWE-693 (protection mechanism failure), CWE-209 (error message information exposure), CWE-1004 (sensitive cookie without HttpOnly).
  11. The client's methodology document, ./.pentest.md - phase model, evidence contract and gate definitions.

Change log for this document

Date (UTC) Version Change Reason
2026-11-10 0.1 Title block, document control, premise and scope Gate G0 artefacts completed before testing
2026-11-10 0.5 Scope, methodology and coverage model Written after P1 and P2, before P3
2026-11-10 0.9 Findings F-01 to F-15, risk register, attack narrative Written from the evidence corpus after P3 and P4
2026-11-10 1.0 Remediation roadmap, retest plan, appendices, consistency pass Issued for client action
2026-11-10 1.0.1 Corrected internal cross-references and finding order; replaced the illustrative password-policy command with the observed one; escaped table pipes and made every evidence link workspace-relative Internal consistency and readability review before issue
1413.4ms