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?

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.

text
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)
Save this as scope.txt in your workbench folder. Change the port if your Day 1 server used a different one.

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.

bash
curl -sI http://127.0.0.1:8000/ | head -n 10
-s hides the progress bar, -I sends a HEAD request and prints only headers. Expect a status line plus headers such as Server and Date.
text
You 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]
The prompt enforces Day 3 habits: assumptions, confidence labels, and a test for every claim.
bash
curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:8000/robots.txt
Tests a typical claim such as robots.txt exists. -o discards the body and -w prints only the status code. 200 means it exists, 404 means the claim was wrong.

If 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?

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.

markdown
| # | Claim | Test command | Expected | Actual | Status |
|---|-------|--------------|----------|--------|--------|
| 1 | Server sends a Server header | curl -sI URL | Server: line | Server: SimpleHTTP | confirmed |
One row per claim. Status is confirmed, wrong or unclear. Actual is pasted from your own terminal.

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.

bash
grep -niE "cookie|token|password|authorization|bearer" scope.txt plan.md
Searches for common secret words, case-insensitive with line numbers. No output means nothing obvious leaked. Matches need a second look.

If 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?

2. The assistant says a /admin path exists. curl returns 404. What is the correct record?

3. Which test is weakest evidence for a claim about a response header?

4. What makes a plan reproducible by someone else?

Finish the day

Mark the day complete to save your progress.

Go to Day 5

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.

Tell someone you are doing this:WhatsAppXLinkedIn

Your notes

Private to this device. Write what you want to remember from today.