Day 4 of 2160 minShell Walker
Day 4: From Scope Statement to a Verified Test Plan
Taught by Mr Elite Updated
By the end of today you can
- Turn a scope statement into a checklist of allowed and forbidden actions
- Draft a test plan with an assistant using only redacted, safe input
- Verify each claim in the plan against your local server and record the result
- Write the plan up as a one-page document someone else could follow
Warm-up
Answer from memory first, then tap to check. Recalling yesterday is what makes it stick.
Name two kinds of invented detail that assistants most often get wrong with confidence.
Invented flags, endpoints and CVE numbers. Any two of these.
Two assistants give you the same answer about a header. Is that proof? What is?
No. Agreement is not proof. A test you ran yourself, at the right layer, that could have failed is proof.
Imagine you have a scope page open in one tab and a blank notes file in the other. You know the rules matter, you know an assistant could draft a plan in seconds, and you know it may quietly add a test that your programme forbids or a header that does not exist. A fast plan that breaks the rules is worse than no plan.
Today is a review day. We combine setup from Day 1, scope and redaction from Day 2, and verification from Day 3 into one habit: scope in, plan drafted, claims tested, plan recorded. You will do it against the local server from Day 1, treating it as if it were a real in-scope target. Everything runs on your own machine.
The pipeline in one picture
Let me put the whole method on the whiteboard. Four stages, always in this order. First, scope: what am I allowed to touch, and how. Second, redact: strip anything private before an assistant sees it. Third, draft: the assistant proposes a plan from the safe input. Fourth, verify: I test every factual claim myself and record the result.
Notice that the assistant only sits in stage three. It never decides what is in scope, it never sees secrets, and it never has the last word on what is true. You are the person accountable for every request that leaves your machine.
- Test plan
- A short written list of what you will test, in what order, with what tools, and what counts as a finding.
- Out of scope
- Anything the programme says you must not test, such as other domains, denial of service, or social engineering.
- Claim
- Any factual statement in the plan, for example that the server returns a given header or that a path exists.
Quick check
Which stage is the assistant allowed to own?
The assistant drafts. You own scope, truth and every request sent.
Turning scope into a checklist
A scope statement is prose. Prose hides rules. I turn it into three lists: allowed targets, allowed actions, and forbidden actions. If a rule is unclear, I write it down as a question for the programme rather than guess. For today we write a pretend scope for your Day 1 local server.
TARGET: http://127.0.0.1:8000 (my own local server)
IN SCOPE: all paths on that host and port
ALLOWED: GET and HEAD requests, reading headers, curl, Burp proxying
FORBIDDEN: load testing, brute forcing, other hosts or ports
RATE: no more than 1 request per second
QUESTIONS: none (it is my own machine)Look at what the file does. It gives the assistant a boundary and gives you a reference to check each test against. Rate and forbidden actions matter as much as the target.
Watch me do it: scope to verified plan
Now I will walk through the whole pipeline. Use the server from Day 1. Start it again if it is not running, and keep it in its own terminal window.
curl -sI http://127.0.0.1:8000/ | head -n 10You are helping me draft a test plan for my own local test server.
Use ONLY the scope below. Do not add actions outside it.
1. Give a numbered plan in phases.
2. List your assumptions.
3. For each factual claim, label confidence high, medium or low
and give one curl command that would test it.
[paste scope.txt here]curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:8000/robots.txtIf the assistant claims a path exists and you get 404, that is not a failure of your method. That is the method working. You caught it before it reached a report.
Quick check
The assistant's plan includes scanning ports 1 to 65535. Your scope forbids other ports. What do you do?
Scope is your rule. A plan step that breaks it is removed, not negotiated.
Your turn: a plan someone else could follow
A good plan is reproducible. A colleague, or you in three months, should be able to read it and repeat each test without guessing. That means exact commands, expected output, and the date and tool versions.
Structure your one-page plan with these headings: scope summary, assumptions, phases with steps, claims table, removed items, open questions. Keep it to one page. Cut anything that is vague, such as check security headers, and replace it with a command and an expected result.
| # | Claim | Test command | Expected | Actual | Status |
|---|-------|--------------|----------|--------|--------|
| 1 | Server sends a Server header | curl -sI URL | Server: line | Server: SimpleHTTP | confirmed |Review: where the habits slip
Reviewing the first three days, the same errors show up. People paste a whole Burp request, cookies included, because it is quicker. They accept a plan because it looks tidy. They test a claim at the wrong layer, for example reading the HTML when the claim was about a header.
Before you finish, scan your files with grep for anything private. Even on a local server it builds the habit.
grep -niE "cookie|token|password|authorization|bearer" scope.txt plan.mdIf it did not work
Letting the assistant write the scope rules
Copy rules only from the programme policy yourself. Give them to the assistant, never the other way round.
Pasting raw requests with cookies or tokens
Redact first, then run grep for secret words before sending.
Recording the assistant's expected output as the actual result
Paste only what your own terminal printed into the Actual column.
Writing vague steps like check cookies
Give a command, an expected result and a pass or fail rule for every step.
Recap
- The pipeline is scope, redact, draft, verify, record, and the assistant only sits in the draft stage
- Turn scope prose into allowed targets, allowed actions and forbidden actions
- Delete any plan step that breaks scope instead of negotiating with it
- Every factual claim needs a test you ran and a pasted result
- A reproducible plan has exact commands and expected output
- A wrong claim caught by a test is the method working
Cheat sheet
curl -sI URL- Fetch only the response headers quietly
curl -s -o /dev/null -w "%{http_code}\n" URL- Print only the status code
grep -niE "cookie|token|password" file- Scan a file for secret-looking words
Claim table- Claim, test, expected, actual, status
Forbidden list- Actions the plan must never contain
Before the next day
Mission: One-page test plan for the Day 1 server
Write a one-page test plan for your local Day 1 server as if it were an in-scope target. Draft it with an assistant, edit it yourself, and note every claim you verified. This proves you can run the full pipeline from scope to a recorded plan.
About 35 min
You are done when: plan.md: a one-page test plan with a completed claims table, a removed-items note and a redaction check line, plus scope.txt in your workbench folder.
Want more? Give plan.md to a friend or a fresh assistant chat and see whether they can repeat every test without asking you a question. Fix every point where they got stuck.
Quiz
4 questions. Your score is saved with your progress.
1. Why is scope kept as a separate file you write yourself?
Scope is your responsibility. A written boundary lets you check every plan step against it.
2. The assistant says a /admin path exists. curl returns 404. What is the correct record?
A failed claim is valuable evidence. Record it and fix the plan.
3. Which test is weakest evidence for a claim about a response header?
Headers live at the HTTP layer, so page HTML is the wrong layer to test them.
4. What makes a plan reproducible by someone else?
Another person can repeat exact commands and compare their output to what you expected.
Finish the day
Mark the day complete to save your progress.
Next: Day 5 starts the web testing module. You will capture a request in Burp Suite, ask an assistant to help read it, and confirm a reflected XSS flaw, using the scoped and verified habits you built today.
Your notes
Private to this device. Write what you want to remember from today.