Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-v3-0324· DeepSeekHugging Face LMArena Human Preference 140K

I was experimenting with a web app on Hack the Box the other day, and remembered…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Googlegemma-3-27b-it’s answer.
  1. User

    I was experimenting with a web app on Hack the Box the other day, and remembered something about verb tempering. So I went ahead and intercepted a request in Burp, and then literally typed "POST" instead of "GET" in the HTTP header before forwarding. Now I found out that there is a "change request method" option Burp...what does that do? I assume it changes other thing in that request to make it a "true" change of the method?

  2. DeepSeek Assistant

    Great question! You're on the right track with HTTP verb tampering (or method tampering), which is a technique used to test how a web server or application handles unexpected HTTP methods.

    Manual Method Tampering (Typing "POST" instead of "GET")

    When you manually change GET to POST in the request line (e.g., POST /login HTTP/1.1), you're only altering the method in the request line. However, a proper POST request usually requires:

    • A Content-Type header (e.g., application/x-www-form-urlencoded or multipart/form-data)
    • A Content-Length header (if there's a body)
    • A request body (if applicable)

    If you just change GET to POST without adjusting these, the server might reject the request or handle it differently than a "real" POST.

    Burp's "Change Request Method" Option

    Burp Suite’s "Change request method" (right-click on a request → "Change request method") does more than just swap GET to POST (or vice versa). It:

    1. Switches the HTTP method (e.g., GET → POST or POST → GET).
    2. Adjusts headers automatically:
      • If converting GET → POST, it adds:
        • Content-Type: application/x-www-form-urlencoded
        • Content-Length: [calculated]
      • If converting POST → GET, it removes these headers.
    3. Moves the body (if any) to the query string (when converting POST → GET).

    Why This Matters in Security Testing

    • Some web apps enforce strict method handling (e.g., only allowing POST for login).
    • Misconfigured servers might process GET and POST differently, leading to security flaws (e.g., authentication bypass, CSRF issues).
    • Some APIs or frameworks (like Flask, Express, or .NET) may behave unexpectedly when methods are altered.

    Example: Manual vs. Burp's Method Change

    Original GET request:

    GET /admin HTTP/1.1  
    Host: example.com  
    

    Manual change to POST (incomplete):

    POST /admin HTTP/1.1  
    Host: example.com  
    

    → Missing Content-Type and Content-Length; server may reject it.

    Burp's "Change request method" to POST:

    POST /admin HTTP/1.1  
    Host: example.com  
    Content-Type: application/x-www-form-urlencoded  
    Content-Length: 0  
    

    → Properly formatted POST request.

    Takeaway

    • Manual changes are quick but may not work if the request isn't properly structured.
    • Burp’s built-in method change ensures the request is correctly formatted for the new method.
    • Testing both ways can reveal different behaviors (e.g., some endpoints may accept GET but not POST, or vice versa).

    Would you like an example of how this could lead to a security vulnerability?

  3. User

    haha, makes me wonder if I was closer to that flag than I thought I was Will try this next time, thanks!

  4. DeepSeek Assistant

    Haha, you might have been way closer than you thought! 😆

    Since you're playing with HTTP method tampering on Hack The Box, here’s a quick pro tip for next time:

    Common HTB/CTF Tricks with HTTP Methods

    1. Admin Bypass via GET → POST (or vice versa)

      • Some apps check POST for auth but ignore GET.
      • Example: If /admin requires POST, try GET /admin—maybe it leaks data or lets you in!
    2. API Logic Flaws

      • REST APIs often expect GET for reading and POST for writing.
      • Swapping them might bypass checks (e.g., GET /delete?id=1 instead of POST).
    3. Missing Content-Type Exploits

      • If you manually change to POST without headers, the server might parse data differently (e.g., weird parameter injection).
    4. HEAD or PUT Shenanigans

      • Some HTB boxes have misconfigured PUT (file upload) or HEAD (info leaks).

    What to Try Next Time

    • Right-click → "Change request method" (Burp does the heavy lifting).
    • Test all methods: GET, POST, PUT, DELETE, HEAD, PATCH, even garbage like HACK or FLAG.
    • Check response differences: Status codes, hidden data, or errors that leak info.

    You might’ve been one right-click away from that flag! 🚩 Next time, spam all the methods and see what breaks. Happy hacking! 🔥

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.