Testing One Request at a Time with Burp

A profile identifier tells an application which record to return, but it should not decide who is allowed to read it. Testing one request at a time with Burp begins with that distinction. In this lab, a signed-in browser requests account details and the ownership check is still…

A profile identifier tells an application which record to return, but it should not decide who is allowed to read it. Testing one request at a time with Burp begins with that distinction. In this lab, a signed-in browser requests account details and the ownership check is still uncertain. We will capture the normal request, change only the relevant value, and compare the response without losing the original session context.

What should you do next? Simply opening Burp Community Edition doesn’t answer the question. You need a baseline request, a specific change, and observable evidence showing how the server handled that change. Only then can you decide whether you’ve found meaningful behavior or merely produced an unusual response.

This is the practical reason for using Burp Proxy and Burp Repeater. Burp Proxy lets you place Burp between a configured browser and the application so you can inspect requests and responses. Interception means pausing a request before it reaches the server, giving you an opportunity to review or alter it. Burp Repeater lets you take a captured request, send it again manually, change selected parts, and compare the resulting responses. Together, they help turn ordinary browser activity into controlled testing.

The important capability isn’t recognizing Burp’s interface or memorizing where a button appears. It’s understanding how a client request becomes server behavior, identifying which values are under client control, and testing whether the application handles those values safely. This lesson stays with manual inspection and modification in deliberately vulnerable labs. It doesn’t assume that every interesting response is an exploitable vulnerability or that every Burp feature is allowed during an exam.

Before intercepting anything, define the target and the question. Confirm the authorized application host, protocol, port, and any path limitations supplied by the lab. Then constrain Burp’s target scope to match that boundary.

Scope helps you organize the traffic that belongs to the assessment and reduce distracting requests to unrelated services. It doesn’t expand your authorization, and it shouldn’t be treated as a substitute for knowing the written boundary. A browser can contact analytics services, external identity providers, or other hosts that aren’t part of your target.

Now state a testable hypothesis. For example, the application returns the baseline profile when you’re signed in as the owner of the baseline profile. You predict that changing the identifier to the comparison identifier will either be rejected, return only permitted information, or expose another profile.

Those outcomes aren’t equivalent. Write down what evidence would support each interpretation before making the change. That small discipline prevents you from deciding what a response means only after seeing it.

For Burp Proxy to observe the exchange, the browser’s traffic has to pass through the proxy correctly. Encrypted web traffic also has to be handled by the authorized lab setup in a way that lets Burp inspect it. If the browser bypasses Burp, certificate handling is incomplete, the wrong host is open, or another browser profile holds the active session, the expected request may never appear. That’s an environmental problem, not evidence about the application’s security. Confirm the data path before interpreting application behavior.

With interception enabled, request your own profile through the browser. Burp pauses the outgoing request. Read it as a message rather than a wall of text.

Identify the request method, destination, path, query parameters or body values, relevant headers, and session state carried by cookies or other tokens. Ask which fields came from your browser and which ones the server is expected to validate. The profile identifier may be visible, but the request could also depend on an active session, an anti-forgery token, or another state value.

Preserve this unmodified request as the baseline. Forward it and observe the complete response. A useful baseline includes more than the HTTP status code.

Record whether the server returned the expected profile, redirected the browser, set or changed a cookie, produced an error, or included a recognizable account value in the response body. If possible, repeat the unchanged request once. A stable baseline makes later differences easier to attribute to your modification rather than to an expired session or changing page content.

Next, send the captured request to Burp Repeater. Repeater separates manual testing from ordinary browser navigation. You can resend a request without rebuilding the entire interaction in the browser, then edit a selected value and send another version.

That control matters because a good comparison changes as little as possible. If you alter the profile identifier, request method, cookie, and path at the same time, a different response won’t tell you which change mattered. Keep the valid session and request structure while testing the identifier alone.

Suppose the baseline request for the baseline profile returns your own name and account details. Change only the identifier to the comparison identifier and send the request. Compare the new response with the baseline.

A response containing a different user’s protected details would directly support the conclusion that this request exposed information belonging to another profile under the tested session. It would not, by itself, prove that every profile is accessible, that data can be modified, or that the same behavior exists under a different account role. Those require separate evidence.

The strongest comparison keeps the session, endpoint, method, and request shape constant. In the baseline, the signed-in session asks for the baseline profile and receives the expected account details. In the modified request, that same session asks the same endpoint for the comparison profile. If the second response identifies the comparison profile and includes that profile’s protected information, the observed difference lines up with the one input you altered. That’s much stronger evidence than noticing only that the page looks different.

Even then, keep the claim narrow. You’ve shown what one endpoint returned for two identifiers under one authorized test session. You haven’t yet shown whether the application permits updates, whether other endpoints use the same authorization logic, or whether another role gets the same result. Repeater helps you control and reproduce the request, but it doesn’t decide the impact. Your conclusion comes from matching the changed input to the returned identity and data, then stating exactly which conditions you tested.

Status codes need the same restraint. A two hundred response means the server returned a successful HTTP response, but it doesn’t prove that the requested action succeeded. The body might contain a sign-in page, a generic error, or a message saying access was denied.

A redirect could send you to your own profile or back to authentication. A forbidden response supports the narrower observation that this particular request was rejected under the current conditions. Read the body, headers, resulting identity, and application state together rather than treating one indicator as a verdict.

The proxy captures the exchange, while Repeater lets you repeat a controlled version of it. Neither tool decides whether authorization was bypassed. That conclusion depends on the known user, the requested profile, and the response produced after a deliberate change.

The reverse problem also occurs. Two responses may have the same status and similar length while containing materially different information. One could show your account and the other could show another user’s account.

Conversely, a changed response length may come from a rotating token, timestamp, personalized greeting, or harmless formatting difference. Comparison is a way to focus your attention, not an automatic vulnerability decision. Look for the specific evidence predicted by the hypothesis, such as a different profile identifier paired with information that the current user shouldn’t receive.

Once you’ve observed a meaningful difference, validate it manually. Repeat the modified request to see whether the result is reproducible. Return to the original identifier and confirm that the baseline still behaves as expected.

If the lab provides separate test accounts, use only those authorized identities to verify whether the behavior depends on the account or role. These checks help establish the relationship among prerequisite, request change, and result. One surprising response can suggest a path, but a controlled sequence makes the reasoning defensible.

Now consider an unsuccessful attempt. You change the identifier in Repeater and receive a sign-in page with a two hundred status. It’s tempting to conclude that the application isn’t vulnerable.

First inspect the state carried with the request. The session may have expired, the cookie may have been omitted, or the request may include a token that’s no longer valid. In that case, you haven’t tested authorization between profiles. You’ve tested how the application responds when the session or request state is unacceptable.

Isolate that assumption with a lower-impact check. Resend the untouched baseline request using the same Repeater tab. If the baseline also returns the sign-in page, restore a valid lab session and capture a fresh request before repeating the identifier test.

If the baseline succeeds but only the modified request fails, compare the exact request values and response content. Perhaps the identifier format is wrong, the requested profile doesn’t exist, or the server genuinely enforced access control. Each possibility predicts different evidence, so don’t jump from failure to absence of a vulnerability.

When the untouched baseline succeeds but the modified request fails, you’ve localized the difference, but you still haven’t explained it. Compare the two requests carefully and ask whether the identifier was the only meaningful change. If it was, the response may reflect authorization enforcement, an invalid identifier, or an object that doesn’t exist. The response body and resulting application state may help distinguish those possibilities, but don’t assign a cause that the evidence can’t support.

The order of operations matters here. First confirm that the same session can still retrieve the authorized baseline. Then resend the single modified value without changing the method, path, cookies, or other state.

If the result remains stable across that controlled sequence, you can describe it precisely. Perhaps the tested identifier was rejected, or perhaps the server returned no protected information. Either statement is narrower and more defensible than claiming the entire application is secure. A failed attempt becomes useful when it identifies which condition held and which question remains unanswered.

A forbidden response deserves similar care. If the comparison profile returns a clear denial while the baseline profile still succeeds, you’ve observed enforcement for those two requests under that session. Record it as a negative test result rather than a universal claim that access control is correct everywhere. If a different valid lab identifier produces another user’s information, the earlier denial may have reflected a nonexistent object, a special account, or another target-specific condition. Change one relevant assumption at a time and preserve both paths.

This manual rhythm is more valuable than random request editing. Establish a baseline, make one targeted change, compare the response, validate the resulting identity or data, and then decide what the observation justifies. Automation can accelerate some training tasks, but it can also generate a large collection of responses without clarifying why they differ. Manual Repeater work keeps the relationship between input and outcome visible. That makes it easier to explain the mechanism and reproduce the result under the constraints that apply to your assessment.

Your notes should preserve that relationship. Record the authorized target identifier, the account or role used, the relevant prerequisite state, and the exact endpoint tested. Save a clean baseline request and the modified request, along with the response details that establish the difference. Include the request method, changed parameter, significant headers or state values, meaningful response content, and the time or sequence when state may matter. Sensitive session material should be handled securely and redacted from report copies when exposing it isn’t necessary to reproduce the finding.

Screenshots can help show visible evidence, but they shouldn’t carry the entire explanation. A technically competent reader needs to understand what request was sent, which value changed, what the server returned, and why that response matters. A screenshot of Burp showing a two hundred status doesn’t establish unauthorized access. A stronger record connects the active test identity, the modified object identifier, and the protected information returned. It also states the limits of the observation, such as the specific accounts, endpoint, and lab conditions actually tested.

Think of the record as enough context to reconstruct the comparison without relying on the tester’s memory. The baseline should establish the authorized identity and expected response. The modified request should make the changed value easy to identify. The corresponding response should preserve the content that demonstrates whether the server returned another identity, denied access, redirected the session, or produced an ambiguous result. That connection matters more than the sheer number of captured messages.

Your written finding should also separate observation from interpretation. An observation might be that a request made under one lab account returned information labeled with a different profile identifier. The interpretation is that the tested endpoint failed to keep those profiles separated under the observed conditions. Keeping those parts distinct makes the reasoning easier to review and keeps the report from claiming more than the requests actually proved. It also leaves a clear starting point for the next bounded test or for a mitigation decision.

Keep failed attempts as well. You don’t need to preserve every accidental click, but a meaningful failed request can show how you eliminated an explanation. For example, note that the first modified request returned the sign-in page because the baseline session had expired. Then record that you established a fresh session, confirmed the baseline, repeated the single identifier change, and obtained the final result. That sequence allows another tester to distinguish an application finding from a stale-session artifact and reduces the chance that you’ll repeat the same troubleshooting later.

For this workflow, focus on the manual action you can explain. You captured a browser request from an authorized target, limited your working scope, preserved a baseline, changed a specific client-controlled value, and compared the server’s responses. You then checked whether the observed result changed data, identity, authorization, or only presentation.

That explanation is more useful than saying that Burp found something. Burp carried and replayed the messages. Your evidence-based interpretation established what the application did under the tested conditions.

A web proxy is most useful when it preserves a baseline and lets you compare one controlled request change at a time. Put the reasoning to a final test: What single request element will you change, and what comparison will show why the response changed? You can revisit the key explanations and answer guide in the companion study reference. This lesson was produced by Bare Metal Cyber dot com.

Testing One Request at a Time with Burp
Broadcast by