password-authentication is a local, self-contained laboratory instrument for auditing password authentication against a target the operator controls. It is built for one technical operator working on their own machine, deliberately breaking authentication in a controlled environment in order to learn how it fails.
The product's intent is to make a password-auditing exercise legible and honest from end to end: the operator configures a deliberately vulnerable local test authentication service, supplies test usernames and a locally generated test password list, optionally sets concurrency, generates or reads candidate passwords, dispatches each candidate through a worker pool against the controlled service, analyzes the controlled application's response to decide accept or reject, and reviews attempts/second, number tested, the successful laboratory credential, error counts, and runtime/logs.
The audience is a single active human role — the Laboratory Operator — a technical practitioner running an exercise against a service they own and control. The product is not a commercial pentest platform, not a multi-tenant service, and not a tool aimed at third-party systems.
The system is a local laboratory bench with a browser-based console and a local backend. The operator configures a run, produces candidates, watches a queue and worker pool process them against a deliberately vulnerable local test authentication service, and reads the analyzed verdicts and results.
Current delivery consists of seven first-party pages — Landing, Run Configuration, Candidates, Queue, Run, Analysis, and Results — all owned by the application and all reachable without an access requirement. The single active human actor is the Laboratory Operator. The deliberately vulnerable local test authentication service is an external, operator-controlled system that the product points at; it is not a page and not a persona.
Accepted behavior covers: run input configuration (controlled target, test username(s), locally generated test password list, optional concurrency settings); a candidate generator that generates or reads candidate passwords using dictionary, rule-based, and exhaustive combination approaches; an attempt engine that sends each candidate to the deliberately vulnerable local test authentication service and records whether the laboratory service accepts or rejects it; a response analyzer that determines success/failure from the controlled test application's response while accounting for the false positives that come from relying only on HTTP status codes; a concurrency/queue layer where a worker pool processes candidates and a central queue tracks pending, successful, and failed attempts; and results reporting of attempts/second, number tested, successful laboratory credential, error counts, and runtime/logs.
Narrow exclusions: the product is scoped to laboratory testing against a deliberately vulnerable local test authentication service that the operator controls. Test passwords must come from a locally generated test password list. Response analysis must use the controlled application's response and must not rely only on HTTP status codes.
Delivery. The product is delivered as a local application: a first-party console (browser UI) plus a local backend that performs candidate generation, queueing, worker-pool dispatch, attempt execution, response analysis, and results/logging. The backend is required because the attempt engine, worker pool, and central queue are long-running, stateful processes that the operator starts, watches, and stops.
Access ownership. Every page in the current contract is application-owned and carries no access requirement. The product is a single-operator local instrument; no accepted journey requires private, resumable, actor-bound state that must be protected from another human, and no accepted source statement establishes application-owned identity, sign-in, or differentiated permissions. Access to the console is therefore open within the local deployment, and no account-management capability is part of this product.
Target ownership. The deliberately vulnerable local test authentication service is external to the product and owned by the operator. The product never provisions, hosts, or hardens that service; it only sends candidates to it and reads its responses. The operator is responsible for the service being deliberately vulnerable, local, and under their control.
Current vs. future. Everything in this document is current. No future-horizon requirements were accepted in the authoritative thread; nothing here is deferred.
Not applicable. No reference directive in this project declares content_source, so no source content inventory is produced.
FR-1 — Configure the run inputs. As a Laboratory Operator, I should configure the target I control, my test username(s), a locally generated test password list, and optional concurrency settings, so that a run is fully specified before any attempt is made.
FR-2 — Generate or read candidate passwords. As a Laboratory Operator, I should generate or read candidate passwords using dictionary, rule-based, or exhaustive combination approaches, so that I have a candidate set to test.
FR-3 — Send each candidate to the deliberately vulnerable local test authentication service. As a Laboratory Operator, I should have each candidate sent to a deliberately vulnerable local test authentication service, so that the laboratory service's accept or reject behavior is exercised.
FR-4 — Record whether the laboratory service accepts or rejects each candidate. As a Laboratory Operator, I should have the attempt engine record whether the laboratory service accepts or rejects each candidate, so that every attempt has a durable outcome.
FR-5 — Determine success/failure from the controlled test application's response. As a Laboratory Operator, I should have the response analyzer determine success or failure from the controlled test application's response, so that verdicts reflect the application's actual behavior.
FR-6 — Account for status-code-only false positives. As a Laboratory Operator, I should be able to see where relying only on HTTP status codes would have produced a false positive, so that I do not trust a status-code-only verdict.
FR-7 — Process candidates through a worker pool. As a Laboratory Operator, I should have a worker pool process candidates, so that attempts proceed concurrently under my optional concurrency settings.
FR-8 — Track pending, successful, and failed attempts in a central queue. As a Laboratory Operator, I should have a central queue track pending, successful, and failed attempts, so that I can see the state of the whole run at a glance.
FR-9 — Report attempts/second. As a Laboratory Operator, I should see attempts per second, so that I know the throughput of the run.
FR-10 — Report the number tested. As a Laboratory Operator, I should see the number tested, so that I know how much of the candidate set was exercised.
FR-11 — Report the successful laboratory credential. As a Laboratory Operator, I should see the successful laboratory credential when one is found, so that I know which candidate the laboratory service accepted.
FR-12 — Report error counts. As a Laboratory Operator, I should see error counts, so that I can distinguish genuine rejects from failures of the run itself.
FR-13 — Report runtime and logs. As a Laboratory Operator, I should see runtime and logs, so that I can reconstruct what happened during the run.
FR-14 — Keep the target deliberately vulnerable, local, and operator-controlled. As a Laboratory Operator, I should only ever point the tool at a deliberately vulnerable local test authentication service that I control, so that the exercise stays a laboratory exercise.
FR-15 — Source test passwords from a locally generated test password list. As a Laboratory Operator, I should supply test passwords from a locally generated test password list, so that the exercise uses locally generated test material.
FR-16 — Never rely only on HTTP status codes. As a Laboratory Operator, I should have response analysis use the controlled application's response rather than only HTTP status codes, so that verdicts are not false positives.
Product context. The Laboratory Operator is the single active human role in this product. They work locally, on their own machine, against a deliberately vulnerable local test authentication service that they themselves control. They are running a laboratory exercise: they want to see how authentication fails, and they want the instrument to be honest about what it observed.
Primary goal. To run a complete password-auditing exercise against their own controlled local test authentication service and come away with a trustworthy result: how many candidates were tested, how fast, which candidate the laboratory service accepted (if any), how many attempts errored, and what the runtime and logs say happened.
Distinct accepted responsibilities.
Relevant inputs and decisions. The operator decides which controlled local target to point at, which test usernames to test, which locally generated test password list to use, which candidate-generation approach to apply, and whether to set concurrency settings at all (they are optional). They decide when to start and stop a run, and they decide whether a flagged false-positive attempt warrants a re-run.
Interactions with other accepted participants. The Laboratory Operator is the only accepted human participant. The deliberately vulnerable local test authentication service is an external, operator-controlled system that the product sends candidates to and reads responses from; it is not a persona and does not act within the product. No other human participant is affected by the run.
Observable success. The run completes with every candidate carrying a recorded outcome; the queue ledger shows pending, successful, and failed attempts resolved; the analysis shows verdicts derived from the controlled application's response with false-positive risk named rather than hidden; and the results show attempts/second, number tested, the successful laboratory credential when one was found, error counts, and runtime/logs.
The creative direction is authoritative for this section. The muse is Susan Kare; the headline idea is charming clarity for a laboratory instrument — a well-built instrument with a personality, legible at a glance, honest about state, never pretending to be more than it is.
Colour tokens (light mode).
| Role | Token | Value |
|---|---|---|
| Background (desktop ground) | --bg | #EDEDE8 |
| Surface (window panel) | --surface | #FFFFFF |
| Text / rules / primary | --ink | #111111 |
| Accent — confirmed laboratory credential, destructive actions | --signal-hit | #E23B2E |
| Accepted / healthy worker state | --signal-ok | #2E9B4F |
| Pending and warnings | --signal-pending | #E8A400 |
| Informational counters, queue in-flight row | --signal-info | #2F6FB5 |
| Muted secondary text | --muted | #7A7A72 |
Proportion: ~70% pale grey ground, ~22% white panels, ~6% black rules and type mass, ~2% signal pixels. Every signal colour appears only as a shape no larger than a 16px icon or a 2px rule — never as a fill or wash. The interface stays monochrome until something actually happens. No blue or indigo primary; no blue-on-white button; the only action colour is black.
Typography.
0.04em tracking, no bold (single weight), sized by scale not weight. Used at large sizes for numerals, section titles, and status readouts.clamp(56px, 8vw, 96px).Shape language. Hard 2px black outlines on every panel, input, and button. No soft shadows, no blur, no gradients anywhere. Corners are square (0px radius) for panels and 4px for buttons and inputs, so controls read as pressable keys. A 1px black rule separates every label/value pair. Icons are drawn on a 16px pixel grid with 1px black strokes and a single flat signal-colour fill. Progress and meter bars are made of discrete 8px blocks, not continuous fills. Focus states are a 2px accent outline offset by 2px — visible, never a glow.
Layout. Desktop-lab layout at 1280px: a 64px-tall top bar carrying the wordmark, the local target host string in monospace, and the run-state pixel lamp; below it a 12-column grid where the left 3 columns are the persistent run rail (target, usernames, wordlist, concurrency) and the right 9 columns are the active surface, switched by a tab strip: Candidates / Queue / Run / Analysis / Results. Panels sit on the grey ground with 24px gutters and never bleed. At 768px the rail collapses to a horizontal settings strip above the surface. At 375px everything is one column, panels full-width with 16px gutters, the tab strip becomes a horizontally scrollable row of 44px-tall keys that never clip their labels, and every value cell wraps rather than truncating. Numeric results are laid out as a labelled table with hairline rules, not as a grid of identical cards.
Imagery. No photography. The imagery is the interface itself plus a small library of 16px and 32px pixel pictograms drawn on the grid: a key, a padlock (open and closed), a queue stack, a worker gear, a stopwatch, a magnifier over a response body, a clipboard of logs, a warning triangle. Plus one larger 96px pixel composition used on the landing hero: a padlock with a comb of candidate keys marching into it, drawn in flat black with a single red pixel where the key turns. Diagrams are drawn in the same pixel grid so the whole product looks cut from one bitmap.
The landing first screen is not a centred SaaS hero. It is a full-width pixel instrument panel.
On the left, a 96px (56px on mobile) VT323 headline set in two stacked uppercase lines — LAB AUTH BENCH over AGAINST YOUR OWN TARGET — flush left, black on the pale grey ground, occupying roughly 9 of 12 columns and running edge to edge of the content grid. Beneath it, a 2px black rule spans the full viewport width.
Under the rule, a single wide white panel with a 2px black outline holds the 96px pixel padlock-and-keys composition on the left — a padlock with a comb of candidate keys marching into it, flat black with a single red pixel where the key turns — and, on the right, one monospace paragraph of 15px body copy explaining that this tool only ever points at a deliberately vulnerable local service the operator controls, plus a black square button reading OPEN RUN CONFIGURATION with a hard 2px black shadow offset 4px down-right.
In the top-right corner of the viewport, a 3-state pixel lamp (IDLE / READY / RUNNING) sits in the top bar. Nothing is centred, nothing floats, no gradient appears anywhere. The concept recomposes only accepted content, states, and controls: the constraint statement, the run-state lamp, and the single path into Run Configuration.
Interaction Model: Static Motion Tempo: restrained Hero Dimensionality: flat
Landing Hero Motion Brief. The focal subject is the 96px pixel padlock-and-keys composition: a padlock with a comb of candidate keys marching into it, drawn in flat black with a single red pixel where the key turns. The input→transformation→outcome thesis is: candidate keys advance toward the padlock (input) → the comb reaches the lock and the key turns (transformation) → a single red pixel marks the turn, and the run-state lamp in the top bar holds its current colour (outcome). This uses only accepted behavior — candidates, the controlled target, and the run-state lamp — and invents no new capability. The motion vocabulary is frame-by-frame, never eased: discrete steps, no interpolation, no smooth transitions. The composed first frame shows the padlock closed, the key comb at rest, the headline fully set, the 2px rule drawn, and the lamp grey at IDLE. The reduced-motion state holds the composition still: the lamp holds steady on its current colour, counters update without the step, and the stamp appears already filled.
Product-wide motion. Frame-by-frame, never eased. The run lamp blinks at 1Hz while the worker pool is active. Counters tick by swapping digits with a 60ms step and no interpolation. A successful laboratory credential lands as a 3-frame stamp (outline, filled, outline) with a single 2px accent rule drawing under the row. Queue rows move between pending/success/failed columns by instant reposition, not by sliding. Log lines append with a 40ms cursor blink. With prefers-reduced-motion, the lamp holds steady on its current colour, counters update without the step, and the stamp appears already filled.
NFR-1 — Local, self-contained operation. The product runs locally for a single operator. The attempt engine, worker pool, and central queue execute against a deliberately vulnerable local test authentication service the operator controls. Provenance: explicit (hard constraint). Rationale: the product is scoped to laboratory testing against a controlled local service.
NFR-2 — Locally generated test password material. Test passwords come from a locally generated test password list. Provenance: explicit (hard constraint). Rationale: the exercise uses locally generated test material.
NFR-3 — Response analysis fidelity. Response analysis determines success/failure from the controlled test application's response and does not rely only on HTTP status codes, because status-code-only analysis can produce false positives. Provenance: explicit (hard constraint). Rationale: verdicts must reflect the controlled application's actual behavior.
NFR-4 — Honest state reporting. Run state, queue state, counters, and verdicts are reported truthfully: errors are counted separately from rejects, unparseable responses are flagged rather than judged, and a status-code-only false positive is named rather than hidden. Provenance: explicit. Rationale: the operator must be able to trust the instrument's readouts.
NFR-5 — No truncation of operational values. Usernames, host strings, candidate passwords, and log lines wrap or scroll; they are never truncated or ellipsised. Provenance: explicit (creative direction). Rationale: the operator must be able to read the exact value that was tested.
NFR-6 — Readable text and controls at every viewport. Headlines, wordmarks, labels, numbers, and controls stay entirely inside the viewport and their container at 375px, 768px, and 1280px, wrapping or scaling to fit, and no other element covers any part of them. Provenance: explicit (creative direction). Rationale: legibility is a hard requirement of the instrument.
NFR-7 — Reduced-motion support. With prefers-reduced-motion, the run lamp holds steady on its current colour, counters update without the digit step, and the credential stamp appears already filled. Provenance: explicit (creative direction). Rationale: motion is decorative state emphasis, not information the operator depends on.
NFR-8 — Tabular numerals. All counters and numeric readouts use tabular numerals so values never jitter as they update. Provenance: explicit (creative direction). Rationale: fast-refreshing counters must remain readable.
Provenance: the authoritative thread specifies no technology choices. These are coherent defaults for a local, stateful, fast-refreshing console with a long-running backend, and are labeled as defaults rather than user-specified choices.
Constraints (binding).
Assumptions (narrow, labeled).
Exclusions.

AGAINST YOUR OWN TARGET
Local test bench · operator-controlled

AGAINST YOUR OWN TARGET
Local test bench · operator-controlled
No comments yet. Be the first!