Day 1 of 2160 minShell Walker

Day 1: Your Bounty Workbench and First Win

Taught by Mr Elite Updated

By the end of today you can

  • Install and check Burp Suite Community, curl, jq and Python 3
  • Start a local test server on your own machine and fetch a page with curl -i
  • Ask an assistant to explain an HTTP request and response, then test its claims yourself
  • Write a short note on where each assistant was right, wrong or vague

Imagine you capture a strange response and can't tell whether a header matters. You ask an AI assistant, it answers in two confident paragraphs, and you have no idea if it is right. Some of it will be good. Some of it may be quietly wrong. The skill that separates a useful bounty hunter from a noisy one is checking.

Today is a small win with that whole loop. You set up your workbench, run a web server on your own laptop, ask two assistants to explain what you see, and then prove or disprove their claims with curl. By Day 21 you will run a full workflow from scope to report. Today we lay the first brick.

Where you are heading by Day 21

Over 21 days you will move from reading traffic, to finding web flaws like XSS, IDOR, JWT and SSRF issues, to testing AI features for prompt injection, and finally to writing reports that triage teams respect. Every hands-on step runs on your own machine or a named practice lab. Never against a real site without written permission.

The AI assistants are helpers, not oracles. I use them to explain, to brainstorm and to tidy writing. I never use them as proof. Proof comes from a request I sent and a response I saw. That rule starts today.

The method for the whole course fits in four words. Observe means you capture a real request or response. Ask means you get an explanation or an idea from an assistant. Verify means you test that explanation yourself. Record means you save the evidence and your verdict. Today you run that loop once, slowly, on a harmless target.

Install and check your tools

We need five things: curl, jq, Python 3, Burp Suite Community Edition and a text editor. curl is a command line tool that sends web requests and prints the replies. Burp is a proxy, meaning a program that sits between your browser and a website so you can see and edit the traffic. We will not use Burp much until Day 5, but install it now so that is out of the way.

bash
curl --version | head -n 1
jq --version
python3 --version
Prints one version line per tool. Any version number is fine. On Windows without WSL, try python instead of python3.

Your output will look roughly like the block below. The exact numbers differ between machines and that does not matter. What matters is that each line prints a version and none prints an error.

text
curl 8.5.0 (x86_64-pc-linux-gnu) libcurl/8.5.0 OpenSSL/3.0.13
jq-1.7
Python 3.12.3
Example output only. Your versions will differ.

Quick check

Why do we install Burp Suite today if we barely use it until Day 5?

Watch me do it: serve, fetch, explain, verify

Now the full loop. First we create a tiny website, then fetch it, then ask for an explanation, then check it. Everything stays on localhost, which is your own computer and reachable only by you. Follow each step in order and compare what you see with what I describe.

bash
mkdir -p ~/bounty-day1 && cd ~/bounty-day1
echo '<h1>Hello bounty</h1>' > index.html
ls
Creates a working folder and a one-line web page.
bash
python3 -m http.server 8000
Starts a basic web server on port 8000 serving the current folder. Stop it later with Ctrl+C.
bash
curl -i http://127.0.0.1:8000/
Sends a GET request and prints status line, headers and body.

Here is what a typical reply looks like. Dates and version numbers will differ on your machine.

text
HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/3.12.3
Date: Mon, 01 Jan 2024 10:00:00 GMT
Content-type: text/html
Content-Length: 22
Last-Modified: Mon, 01 Jan 2024 09:59:00 GMT

<h1>Hello bounty</h1>
Example response. The blank line separates the headers from the body.

Let me read it with you. The first line is the status line: the protocol version, the status code 200 and the reason text OK. Each line after it is a header, a name and value pair. Content-type tells a browser how to treat the body. Content-Length is 22 because your page is 22 bytes, including the newline that echo added. After the blank line comes the body itself.

Spot the small oddity: the server replied with HTTP/1.0 but its log says the request was HTTP/1.1. curl sent a 1.1 request and Python's simple server answered in the older dialect. That is normal and a good reminder that the two sides of an exchange can differ. Hold on to what you saw, because next we ask the assistants about exactly this.

Ask the assistants, then check them

Copy the curl output from your terminal and paste it into Claude and ChatGPT, each in its own chat. Because this is a local test server, nothing sensitive is in it. From Day 2 you will learn what must never go into a prompt, so treat this as the last time you paste without thinking. Even now, I want you to check the habit: read what you paste first.

text
Explain this HTTP exchange line by line. Then list 3 specific claims you are making that I could verify with curl.

[paste your curl -i output here]
Asking for checkable claims forces the assistant to give you something testable.

You should get a line-by-line walkthrough and a short list of claims. Read both answers fully before testing anything. Copy each claim into a scratch file so you can tick it off. Good claims are concrete, such as 'a request for a page that does not exist returns 404'. Weak claims are vague, such as 'this server is probably fine'. You cannot test the second kind, so mark it vague.

Pick two claims from each answer and test them. For example, if one says the server will answer a HEAD request without a body, try it. If one says a missing page returns 404, try that too. Run the block below in your second terminal while the server is still running.

bash
curl -I http://127.0.0.1:8000/
curl -i http://127.0.0.1:8000/nope.html
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8000/
HEAD request (headers only), a missing page, and a quiet request that prints only the status code. Expect 200, then a 404 response, then 200.

The first command should print the same status line and headers as before but no HTML body. The second should print HTTP/1.0 404 File not found, some headers and a small HTML error page. The third prints just 200. The -s flag hides curl's progress meter, -o /dev/null throws the body away, and -w prints a format string after the request, here the status code. If your results match a claim, mark it confirmed. If not, mark it wrong and note what you saw.

Quick check

An assistant says your server sends a Content-Security-Policy header. What do you do?

Keep a tidy workbench

Good habits cost nothing now and save hours later. Keep one folder per target or lab, and save your raw curl output to files so you can show exactly what happened. Name them in order, such as evidence-001.txt, so the sequence is obvious when you write a report later.

jq is a tool for reading JSON, a common text format for data in APIs, which you will meet constantly. Try it on a tiny example so you know it works. Run the block below in your second terminal.

bash
curl -i http://127.0.0.1:8000/ > evidence-001.txt
echo '{"user":"test","role":"viewer"}' | jq .role
Saves the raw exchange as evidence, then uses jq to pull one field. Expect "viewer" printed with quotes.

The first line prints nothing on screen because the redirect sends the output into the file. Check it with cat evidence-001.txt and you should see the same status line, headers and body as before. The second line should print "viewer". If jq prints a parse error, check that your quotes match exactly as shown.

Finally, create a notes file next to your evidence. A simple pattern works well: claim, source assistant, test command, result and verdict. You will fill this in for your mission, and the same pattern will carry into real bounty notes later.

bash
cat > notes-day1.md <<'EOF'
# Day 1 notes

| Claim | Assistant | Command | Result | Verdict |
|-------|-----------|---------|--------|---------|
EOF
cat notes-day1.md
Creates a Markdown notes file with a table header and prints it so you can confirm it exists.
Status code
A three-digit number in the response saying how the request went, such as 200 or 404.
Header
A name and value pair sent with a request or response that carries extra information.
localhost / 127.0.0.1
Your own machine. Traffic to it never leaves your computer.

If it did not work

Treating an assistant's explanation as verified

Turn each claim into a curl command and compare the output. Write down whether it matched.

Stopping the server by closing the terminal tab and then finding the port busy

Use Ctrl+C in the server terminal. If the port is still busy, use another port such as 8001.

Running curl in the same terminal as the server

Open a second terminal window or tab. The server occupies the first until you stop it.

Pasting data without reading it first

Read every line before you paste. Today it is harmless, but make it a habit before Day 2.

Running the curl commands from the wrong folder or after stopping the server

If curl says 'Connection refused', the server is not running. Return to the first terminal, cd into ~/bounty-day1 and start it again.

Recap

  • The goal is a repeatable method: observe, ask, verify, record
  • Assistants help you understand, but only your own requests prove anything
  • curl -i shows status line, headers and body in one view
  • python3 -m http.server gives you a safe local target
  • Ask assistants for claims you can test, then test them
  • Save raw output as evidence files and write a verdict next to each claim

Cheat sheet

python3 -m http.server 8000
Serve the current folder on port 8000
curl -i URL
Show response headers and body
curl -I URL
Send a HEAD request, headers only
curl -s -o /dev/null -w '%{http_code}' URL
Print only the status code
jq .field
Extract a field from JSON
Ctrl+C
Stop the running server

Before the next day

Mission: Your first verified explanation

Run your own server, capture an exchange, get explanations from both assistants and test their claims. The aim is to feel how often confident text needs checking, and to start your evidence habit.

About 35 min

You are done when: A notes-day1.md file plus evidence-001.txt showing your curl output and your verdict on each assistant's claims

Want more? Add a second page and a custom 404 test, then ask both assistants to predict the exact response before you run curl, and score their predictions.

Quiz

4 questions. Your score is saved with your progress.

1. What does the -i flag in curl -i do?

2. Why ask an assistant to list claims you can verify with curl?

3. Two assistants give the same explanation of a header. What does that prove?

4. Why run today's server on 127.0.0.1?

Finish the day

Mark the day complete to save your progress.

Go to Day 2

Next: Day 2 covers reading a bounty programme's scope and rules, and how to redact sensitive data before it goes into any prompt. Today you pasted harmless output; tomorrow you learn when that is not safe.

Tell someone you are doing this:WhatsAppXLinkedIn

Your notes

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