<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Martin Simonyan on Medium]]></title>
        <description><![CDATA[Stories by Martin Simonyan on Medium]]></description>
        <link>https://medium.com/@aegis-martin?source=rss-9ad96374ef56------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*53Mz43vuGBojlyTnQm3jgA.jpeg</url>
            <title>Stories by Martin Simonyan on Medium</title>
            <link>https://medium.com/@aegis-martin?source=rss-9ad96374ef56------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 04:11:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@aegis-martin/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Are You Really Worse Than AI? Life of a Developer Series]]></title>
            <link>https://osintteam.blog/are-you-really-worse-than-ai-life-of-a-developer-series-20c52b315aaa?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/20c52b315aaa</guid>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Wed, 04 Mar 2026 01:07:07 GMT</pubDate>
            <atom:updated>2026-09-15T15:35:08.329Z</atom:updated>
            <content:encoded><![CDATA[<h3>Are You Really Worse Than AI?</h3><p>Hey heard that the recent AI’s will replace deve — — SHUT THE FUCK UP. AI Here, AI There, AI <strong>EVERYWHERE</strong>. Okay fine Artificial Intelligence is truly one of the greatest achievements of humanity — yet its glorification sometimes turns into dismissing the actual humans behind it. Today I will do well for my fellow <strong>HUMAN</strong> brothers so you learn to use AI as a tool. If you rely on AI too much, are afraid of losing your juicy IT job, or God forbid are a vibe coder — this article is for you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6vUX-LJyN48KBqO1PMNM5w.png" /></figure><h3>Know Your Enemy</h3><p>Self explanatory right? Back in myyyy day when Industrial revolution started a lot of people were left jobless because they failed to adapt to the modern technology but would you call the Train that helped supply the English with food faster an enemy of Englishman? That’s the problem with AI, it is NOT your enemy. <strong>Sloth is</strong>. Companies do not need prompt writers that’s the lamest job there is, for example the images you see in my articles are generated by AI, and I would argue they look much better than average “AI Image” all I did asked one AI to make ‘extra detailed prompt’ for my image then pasted it into another AI. A fucking goldfish can do this, prompt engineer my ass.</p><h3>Why Are You Better</h3><p>Because you can rationalize. That’s the whole point AI is great at doing what its told to do, but unless you know your goal clearly you cannot use it properly, that’s why Web Developer will vibe code a better site than a senior HR manager. A great analogy would be a simple hammer. It is not better than you are because it nails better than your palm, but it is a useful tool and your dad for example <em>is definitely bette</em>r <em>than you are </em>at that specific task, yet you both use the same hammer. Knowing syntax won’t get you far. Knowing how to <em>make it work</em> will. In IT they need <strong>problem solvers. </strong>And before you throw rotten tomatoes on me for saying cliche phrase hear me out. <br>Imagine a scenario - you are asked to write a a working web application for the business, a proper user database, payment systems and shit like that, now lets look at extremes.</p><h4>A Developer that does NOT use AI</h4><p>The quality of your work is strictly limited to the skills you have. If you are a skilled developer than quality might not be a problem but time absolutely will. You will spend a lot of time doing boring pointless shit like <strong>renaming variables, writing exception for every edge case scenario, writing comments on “DON’T TOUCH THIS” on code fragments that are crucial, going trough docs, GitHub, Stack Overflow, to find a single snippet out of pile of garbage. Examples are ton. <br></strong>You as a developer have a single product to offer — <strong>Your Time<em>. </em></strong>And as you can guess, you will need a lot of this by this route.</p><h4>A Fucking Moron</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O4igmRuLk8m4VUIyvm-3Cg.png" /></figure><p>As a vibe coder your goal would be to <em>feeeel</em> the incredible experience of being useful. You will write the application relatively fast. Heck it might even look good, but pray a user doesn’t touch something that never was meant to be touched. Since you are in this publication you might be waiting for me to talk about security aspect, well let’s just say your application will suffer “Of specific word combination that I can’t name on medium but you can search in incognito mode with word ‘hardcore’ in it”. Literally anything will go wrong, and its not just that AI will screw it up, no it’s that AI only does what you tell it do to, how can you explain to imply security hardening on your application when only ‘curl’ you know is a genital hair?<br>Your database has no <strong>input sanitization, your API keys are hardcoded in plaintext, and your auth is a single if statement checking if password equals password</strong>. Whatever horny dreams you have for your bully’s mom don’t even come close to what the Hacker will do to your sorry ass application that’s already bent over and dripping wet.</p><h3>How To Actually Use AI</h3><p>Rule of thumb “If you can’t explain it you don’t understand it, if you don’t understand it you should not code it”. AI should be your Junior assistant nothing more, nothing less. I’ve concluded 4 main ways for using AI that will not leave you fighting for a homeless shelter.</p><h4>Option 1: AI As Reference</h4><p>A common way I personally use AI is to make it write the skeleton of the application while I add muscle to it. For example this is what AI gave me as a reference for my application parser.</p><pre>import argparse<br><br>parser = argparse.ArgumentParser()<br><br># GLOBAL FLAG<br>parser.add_argument(&quot;--verbose&quot;, action=&quot;store_true&quot;)<br><br># SUBCOMMANDS<br>subparsers = parser.add_subparsers(dest=&quot;cmd&quot;, required=True)<br><br>scan = subparsers.add_parser(&quot;scan&quot;)<br>scan.add_argument(&quot;target&quot;)<br><br>args = parser.parse_args()<br><br># CHECK GLOBAL FLAG<br>if args.verbose:<br>    print(&quot;Verbose ON&quot;)<br><br># DISPATCH<br>if args.cmd == &quot;scan&quot;:<br>    print(&quot;Scanning:&quot;, args.target)</pre><p>And what I turned it into</p><pre>import argparse<br>import aegiscli.core.logger as logger<br>import aegiscli.core.flagger as flagger<br><br>def main():<br>    parser = argparse.ArgumentParser(<br>        prog=&quot;aegiscli&quot;,<br>        description=&quot;AegisCLI - modular recon framework&quot;<br>    )<br><br>    # global parser (shared flags)<br>    global_parser = argparse.ArgumentParser(add_help=False)<br>    global_parser.add_argument(&quot;--log&quot;, action=&quot;store_true&quot;)<br>    global_parser.add_argument(&quot;-v&quot;, action=&quot;store_true&quot;)<br><br><br><br>    # main categories<br>    subparsers = parser.add_subparsers(dest=&quot;command&quot;, required=True)<br><br>    # profiler category, inherits global flags<br>    profiler_parser = subparsers.add_parser(<br>        &quot;profiler&quot;,<br>        help=&quot;Profiler tool&quot;,<br>        parents=[global_parser]<br>    )<br><br>    profiler_parser.add_argument(&quot;submodule&quot;, choices=[&quot;whois&quot;, &quot;dns&quot;, &quot;all&quot;])<br>    profiler_parser.add_argument(&quot;target&quot;)<br><br>    args = parser.parse_args()<br><br>    if getattr(args, &quot;log&quot;, False):<br>        logger.start_log()<br><br>    if args.v:<br>        flagger.verbose.enable()<br><br>    try:<br>        if args.command == &quot;profiler&quot;:<br>            from aegiscli.tools.profiler.profiler import Profiler<br>            initializator = Profiler(settings=None, submodule=args.submodule, mode=None, target=args.target)<br>            initializator.selector()<br><br>    except Exception as e:<br>        logger.log(f&quot;[ERROR]: {e}&quot;)<br><br>    finally:<br>        if getattr(args, &quot;log&quot;, False):<br>            logger.stop_log()<br><br><br><br>if __name__ == &quot;__main__&quot;:<br>    main()</pre><blockquote><em>Note:<br>This snippet is from my application </em><a href="https://github.com/martinsimonyan43/AegisCLI"><em>AegisCLI</em></a></blockquote><p>As you can see all I used AI for is for mapping the application in my head so I can picture the structure.</p><p><strong>Recommended when you have your own vision for the application and can implement it.</strong></p><h4>Option 2: AI as Ground-worker</h4><p>There are a lot of fun activities as a developer! Examples can include:</p><ol><li>Write documentation (9/10 Enjoyment)</li><li>Write README (11/10 Excitement)</li><li>Fix Bugs (69/10 Happiness)</li><li>Error Handling (13 Try/Excepts out of 10)</li></ol><p>If we are serious AI does all of this perfectly incredibly fast. Bug fixes and error handling will need some hand holding sure but that still saves ton of time. Writing docs and different .md files are also perfect work for AI.<br><strong>Useful when Application already exists/is almost finished and needs finishing touches.</strong></p><h4>Option 3: AI as Companion</h4><p>Deep reasoning models have a really good argument in their favor it’s <em>reasoning</em>. Smart AI can absolutely give tips and put you on a correct path. For example deciding what framework to use, how to implement it. This is great way to actually think of best way to create/fix something that is complex and you don’t have full knowledge of (happens all the time). AI in this case turns into something in between of a interactive documentation and actual coding buddy. Although this option can backfire if you literally don’t understand shit.</p><p>For example let’s look at my AegisCLI again specifically at module “Profiler” and its submodule “Web Fingerprinter”, (you can check the code if you want at <a href="https://github.com/aegismartin/AegisCLI/blob/main/aegiscli/tools/profiler/submodules/web.py">https://github.com/aegismartin/AegisCLI/blob/main/aegiscli/tools/profiler/submodules/web.py</a>) the name already talks for itself, if you are gonna code that kind of thing you must understand at least some networking and how are applications built, do you? Maybe you do but that’s not something that we remember like breathing, when actually coding it you are forced to open docs, google, and your own notes to create a reliable application. AI is perfect for that task since it can explain concepts to you for refresher, and its really good at it, and then it can check your code to see if you implemented the small details correctly OR help you test it.<br><strong>Great for complex tasks that require actual Brain Power and external knowledge.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1i8zsvTlu4H7ywZmJR0yIg.png" /></figure><h4>Option 4: AI as Freelancer</h4><p>Sooner or later you will have to work with projects that require external skills. As a developer you can know code but you won’t know how to make a proper logo for your project, how to implement proper SEO, how to write the text in your site because you are allergic to normal human interaction. There are a lot of examples really. I believe here completely relying on AI is justified, why? Because for a cybersecurity practitioner to learn UI/UX to make himself a good looking site is moronic. Not that I am a perfect example but my site (check <a href="https://aegismartin.com/">https://aegismartin.com</a> cutie) was created with vibe coding, because I am not a front end developer and never wanted to be one . I know just enough to maintain the site and implement manual fixes (suck it vibe coders) but i can’t write a comparable application because I don’t have infinite amount of time or mental resources. However if the contents of the site were stupid, if I claimed there to know X and was relying on AI to do the X then yes, I would be a moron.</p><h4>Conclusion</h4><p>Use your fucking head don’t go to extremes, your smart anti AI memes and complains are not gonna stop progress. You completely relying on AI will only result you being a disposable worker, so find middle ground adapt your work and have IDEAS not just execution. And for the love of God, <em>go outside and touch grass.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20c52b315aaa" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/are-you-really-worse-than-ai-life-of-a-developer-series-20c52b315aaa">Are You Really Worse Than AI? Life of a Developer Series</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Bash Scripting Guide Every Cybersecurity Beginner Needs]]></title>
            <link>https://osintteam.blog/everything-you-need-to-know-about-bash-beginners-guide-part-1-c37d9f2f0098?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/c37d9f2f0098</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[guides-and-tutorials]]></category>
            <category><![CDATA[bash]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[information-security]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Mon, 26 Jan 2026 07:34:32 GMT</pubDate>
            <atom:updated>2026-01-27T10:19:37.239Z</atom:updated>
            <content:encoded><![CDATA[<p>Bash is a core skill for anyone working with Linux systems, scripting, or automation. In cybersecurity especially, it is one of the primary tools used for task automation, system interaction, and rapid problem-solving. If you cannot comfortably work in Bash, your Linux knowledge is incomplete.</p><p>This guide is designed to give beginners a solid, practical introduction to Bash, with a focus on real usage rather than theory or memorization. Without further ado let’s get started!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*soGUYpW8Rh8TjKTXbHCFGw.png" /></figure><blockquote><em>This Guide is aimed at Security practitioners who want to learn bash, however it will help you understand the language no matter your career. This Guide assumes you already have foundational Linux knowledge which includes:</em></blockquote><blockquote><em>1. Understanding how the file system works in UNIX systems</em></blockquote><blockquote><em>2. Knowing basic commands in Terminal</em></blockquote><h3>Module 1: Why Use Bash For Scripting</h3><p>A bash script is a file containing a sequence of commands that are executed by the bash program line by line. It allows you to perform a series of actions, such as navigating to a specific directory, creating a folder, and launching a process using the command line.</p><p>By saving these commands in a script, you can repeat the same sequence of steps multiple times and execute them by running the script.</p><p><strong>Advantages of Bash scripting include:</strong></p><ul><li><strong>Automation:</strong> Shell scripts allow you to automate repetitive tasks and processes, saving time and reducing the risk of errors that can occur with manual execution.</li><li><strong>Portability:</strong> Shell scripts can be run on various platforms and operating systems, including Unix, Linux, macOS, and even Windows through the use of emulators or virtual machines.</li><li><strong>Flexibility:</strong> Shell scripts are highly customizable and can be easily modified to suit specific requirements. They can also be combined with other programming languages or utilities to create more powerful scripts.</li><li><strong>Accessibility:</strong> Shell scripts are easy to write and don’t require any special tools or software. They can be edited using any text editor, and most operating systems have a built-in shell interpreter.</li><li><strong>Integration:</strong> Shell scripts can be integrated with other tools and applications, such as databases, web servers, and cloud services, allowing for more complex automation and system management tasks.</li><li><strong>Debugging:</strong> Shell scripts are easy to debug, and most shells have built-in debugging and error-reporting tools that can help identify and fix issues quickly.</li></ul><blockquote><em>Most of the time ‘shell’ and ‘bash’ are referred to as the same thing which is false. The term “shell” refers to a program that provides a command-line interface for interacting with an operating system. Bash (Bourne-Again Shell) is the main stream shell for most of the distributions. (About this later).</em></blockquote><h3>Why Bash Matters in Cybersecurity</h3><p>As I mentioned earlier, in cybersecurity, Bash is essential. Here’s why:</p><ul><li><strong>Reconnaissance Automation:</strong> Enumerate subdomains, scan ports, or brute-force directories across hundreds of targets simultaneously. Can be a solid alternative for Python depending on your case.</li><li><strong>Tool Chaining:</strong> Most security tools (nmap, gobuster, ffuf, nikto) output text. Bash lets you pipe one tool’s output directly into another, building custom attack chains without writing Python.</li><li><strong>Persistence and Privilege Escalation:</strong> On compromised Linux systems, Bash is guaranteed to be present. Understanding it means understanding how attackers move laterally, establish persistence, and escalate privileges.</li><li><strong>Log Analysis:</strong> Parse authentication logs, web server logs, or IDS alerts to find patterns, extract IOCs, or detect anomalies. grep, awk, and sed are faster than opening logs in a text editor.</li><li><strong>Rapid Prototyping:</strong> Need a custom exploit wrapper? A payload delivery script? A network monitor? Bash gets it done in minutes, no compilation needed.</li><li><strong>CTF and Labs:</strong> Capture The Flag competitions and pentesting labs expect you to move fast in a terminal. If you’re fumbling with basic Bash, you’re losing time while others are scoring points.</li></ul><p>If you can’t script in Bash, you’re handicapped on Linux systems. And Linux runs the internet.</p><h3>Setup of The Script</h3><p>The Bash scripts often use .sh extension, however Linux is not Windows, here extensions are mostly conventions there are 2 much more crucial points to consider.</p><p><strong>1. Shebang:</strong> Bash scripts start with a shebang. Shebang is a combination of bash # and bang ! followed by the bash shell path. This is the first line of the script. Shebang tells the shell to execute it via bash shell. Shebang is simply an absolute path to the bash interpreter. First thing to do is find where your bash interpreter is located, run the following command.</p><pre>which bash<br>/usr/bin/bash #my response</pre><p>Now that we know where our interpreter is located write #!/usr/bin/bash at top of your script file. Note that yours might be located elsewhere so don&#39;t forget to run this command.</p><p>2. <strong>Permission to Execute:</strong> This one is simple, if you understand file system on Linux you know that a file must have a permission to be executed. Run the following command in your terminal</p><pre>chmod +x script.sh</pre><p>If 2 of these conditions are met you can run even extensionless files.</p><p>Finally, let’s get our hands dirty shall we?</p><h3>Module 2: Syntax Fundamentals</h3><p>Have you ever thought of something that’s both confusing and easy? That’s Bash syntax.</p><p>You probably already guessed but # is used for commenting everything after it will be ignored.</p><h3>1. Variables and Assignment</h3><p>In bash variables are assigned simply:</p><pre>VAR=value<br>#&quot;VAR&quot; is the name and &quot;value&quot; is the content</pre><p>To get the value use the $ prefix. Like this echo $VAR. Note that if the variable has spaces the bash will mess it up by separating them into arguments instead of treating as single string. To avoid it either wrap the name of the variable in &quot;&quot; or the echo &quot;$VAR&quot; command. Note that there should be no spaces when assigning variables VAR = “value” will not work.</p><p>The other crucial point is to use curly braces {} to indicate where the name of the variable ends. For example:</p><pre>name=&quot;John&quot;<br>echo &quot;${name} Doe&quot;</pre><p>Without them bash would be trying to find the wrong variable and screw it up. You can also use unset VAR to delete a variable.</p><h3>2. Quoting and Command Substitution</h3><p>Bash handles text differently depending on how you quote it:</p><ul><li><strong>Single quotes ‘…’</strong> mean literal. Nothing inside expands, no variables, no commands. Bash sees it exactly as you wrote it.</li><li><strong>Double quotes “…”</strong> allow variables and commands to expand but keep spaces intact. This is why we often wrap variables in double quotes.</li><li><strong>Backticks </strong><strong>command or </strong><strong>$(command)</strong> run another command and insert its output in place. The $(...) style is preferred because it’s easier to read and nest. Here is an example:</li></ul><pre>echo &quot;Today is $(date)&quot;</pre><p>Here, $(date) runs the date command, and Bash replaces $(date) with whatever the date command outputs.</p><h3>3. Command and Execution</h3><p>If you know what commands are (which you must), and know some commands yourself (which you should) you can integrate them in your script. You can also chain your commands for example</p><pre>git clone https://github.com/bestrepoever.git &amp;&amp; cd bestrepoever<br>#The second command will work only if first command suceeded.<br>sudo dnf install btop || sudo dnf install htop<br>#The second command will run only if first one fails.</pre><h3>4. Conditionals</h3><p>The standard conditional in Bash starts with if, checks a condition, and then runs commands:</p><pre>if [ condition ]; then<br>    commands<br>elif [ another_condition ]; then<br>    commands<br>else<br>    commands<br>fi</pre><p>The [ ], are actually a special Bash command called test. Notice the spaces are mandatory around the brackets.</p><p>For example:</p><pre>num=10<br>if [ &quot;$num&quot; -gt 5 ]; then<br>    echo &quot;Greater than 5&quot;<br>else<br>    echo &quot;5 or less&quot;<br>fi</pre><p>Here, -gt means “greater than.” Bash sees if $num is bigger than 5, and runs the appropriate branch.</p><p>[[ ]] is a safer Bash-only version. Inside it, you don’t have to worry as much about quoting variables or weird word splitting, and it can also do pattern matching:</p><pre>filename=&quot;test.txt&quot;<br>if [[ $filename == *.txt ]]; then<br>    echo &quot;This is a text file&quot;<br>fi</pre><p>== *.txt checks if $filename ends with .txt.</p><h3>5. Loops</h3><p>Loops let you repeat commands, there are multiple of them in bash:</p><p><strong>For Loop: Iteration over List</strong></p><pre>for var in 1 2 3; do<br>  echo $var<br>done</pre><p>Bash runs echo $var once for each item in the list: first 1, then 2, then 3.</p><p><strong>C-style for loop: Literally like in C</strong></p><pre>for ((i=0; i&lt;5; i++)); do<br>  echo $i<br>done</pre><ul><li>i=0 starts the counter</li><li>i&lt;5 is the condition to continue looping</li><li>i++ increases i by 1 after each loop</li></ul><p><strong>While loop: Runs the command until condition becomes false</strong></p><pre>count=1<br>  while [ $count -le 3 ]; do<br>      echo &quot;Count is $count&quot;<br>      ((count++))<br>  done</pre><ul><li>`[ $count -le 3 ]` checks “is count less than or equal to 3?”</li><li>((count++)) increases count by 1 each loop.</li><li>The loop stops when the condition becomes false.</li></ul><h3>6. Functions</h3><p>Functions to put it simply, are reusable bundles of commands. Example</p><pre>#!/usr/bin/bash<br># Define a function that greets a user<br>greet_user() {<br>    local name=$1       # $1 is the first argument passed to the function<br>    local age=$2        # $2 is the second argument<br>    echo &quot;Hello, $name! You are $age years old.&quot;<br>    echo &quot;Number of arguments passed to this function: $#&quot;<br>    echo &quot;All arguments: $@&quot;<br>}<br># Call the function with arguments<br>greet_user &quot;John&quot; 17<br>greet_user &quot;Jane&quot; 25</pre><p><strong>Explanation:</strong></p><ol><li>greet_user() defines the function.</li><li>Inside the function:</li></ol><ul><li>local name=$1 grabs the first argument passed when you call the function.</li><li>local age=$2 grabs the second argument.</li><li>$# counts how many arguments were passed.</li><li>$@ expands to all arguments.</li><li>We call it twice with different names and ages.</li></ul><p>3. Using local ensures name and age exist only inside the function. Outside, they don’t exist.</p><h3>Module 3: Data, I/O, and Script Safety</h3><p>Now that we somewhat understand the syntax of bash we can move to more advanced subtopics:</p><h3>1. Arrays</h3><p>Arrays store multiple values in one variable. Example</p><pre>array=(one two three)<br>echo ${array[0]}       # prints first element: one<br>echo &quot;${array[@]}&quot;     # prints all elements safely: one two three</pre><p>&quot;${array[@]}&quot; keeps each element as it is, even if it has spaces. Without quotes, Bash splits each word separately.</p><p>There are also Associative arrays (like dictionaries):</p><pre>declare -A assoc<br>assoc[name]=&quot;John&quot;<br>assoc[age]=17<br>echo ${assoc[name]}    # prints John</pre><blockquote><em>If you are unfamiliar with associative arrays (dictionaries), they are like lists, but they consist of key: value</em></blockquote><p>declare is needed for making a <em>special</em> variable and -A tells bash that this is associative array, assoc is the name of the array.</p><h3>2. Redirection</h3><p>Redirection tells Bash where input comes from and where output goes.</p><pre>echo &quot;Hello&quot; &gt; file.txt # send output to file.txt, overwrite<br>echo &quot;Hello again&quot; &gt;&gt; file.txt # append output<br>ls nonexistent 2&gt; error.log # redirect error messages<br>ls &gt; output.log 2&gt;&amp;1 # redirect both stdout and stderr<br>cat &lt; file.txt #reads input from a file<br>cat file.txt | grep &quot;Joshua&quot; #Output of the first command becomes input of the second command<br>diff &lt;(ls dir1) &lt;(ls dir2)  # &lt; is a process substitution it makes output look like a file <br>#Here it compares two directories as if they are files (diff won&#39;t work otherwise)</pre><h3>3. Parameter Expansion</h3><p>Bash can work with variables in advanced ways.</p><pre>echo ${VAR:-default}   # if VAR is empty, use &quot;default&quot;<br>echo ${VAR:=default}   # if VAR is empty, set it to &quot;default&quot;<br>echo ${VAR:+other}     # if VAR exists, use &quot;other&quot;<br>echo ${VAR:?error}     # exit script if VAR is empty</pre><p>We can also do <strong>string manipulation:</strong></p><pre>text=&quot;HelloWorld&quot;<br>echo ${text:0:5}      # first 5 characters (starts from 0) → Hello<br>filename=&quot;file.txt&quot;<br>echo ${filename%.*}   # remove extension → file<br>sentence=&quot;one two one&quot;<br>echo ${sentence//one/three}  # replace all &#39;one&#39; → three two three</pre><h3>4. Arithmetic</h3><p>One of the main differences between you and bash is that it can do math.</p><pre>((a = 5 + 3))   # sets a to 8<br>((a++))         # increment by 1 → a=9<br>b=$((a * 2))    # b=18</pre><ul><li>$(( ... )) calculates and returns a value.</li><li>(( ... )) can be used directly in conditionals like this:</li></ul><pre>if (( a &gt; 10 )); then<br>  echo &quot;Greater than 10&quot;<br>fi</pre><h3>5. Special Variables</h3><p>Bash has built-in variables you can use everywhere:</p><ul><li>$0 → script name</li><li>$1, $2, ... → first, second, etc., command-line arguments</li><li>$@ → all arguments as a list</li><li>$# → number of arguments</li><li>$? → exit status of last command (0 = success, anything else = error)</li><li>$$ → process ID of this script</li><li>$! → process ID of last background job</li></ul><blockquote><em>Exit codes follow a convention: 0 means success, 1–255 indicate various failures. This matters when chaining commands or checking if operations succeeded.</em></blockquote><p>For example:</p><pre>echo &quot;Script name: $0&quot;<br>echo &quot;First argument: $1&quot;<br>echo &quot;Number of arguments: $#&quot;<br>#And so on</pre><h3>6. Error Handling</h3><p>Your scripts will fail sooner or later for various reason, half of the time it won’t even be your fault, the interesting thing about bash is that by default it will continue running after getting an error, which sometimes can be dangerous.</p><p><strong>1. Exit on Error</strong></p><pre>set -e<br># Script exits immediately if any command fails (returns non-zero exit code)</pre><p>set -e helps in preventing cascading failures.</p><p><strong>2. Exit on Undefined Variables</strong></p><pre>set -u<br># Script exits if you reference a variable that doesn&#39;t exist</pre><p>This catches typos. If you write $USRNAME instead of $USERNAME, Bash will error out instead of silently treating it as empty.</p><p><strong>3. Pipefail</strong></p><pre>set -o pipefail<br># Makes pipelines return the exit code of the first failed command</pre><p>Normally, command1 | command2 only checks if command2 succeeded. With pipefail, if command1 fails, the whole pipeline fails.</p><p><strong>4. Combine Them (Best Practice)</strong></p><pre>#!/usr/bin/bash<br>set -euo pipefail<br># Now your script is strict: no silent failures, no undefined variables, no broken pipes</pre><p><strong>5. Check Exit Codes Manually</strong></p><pre>if ! ping -c 1 192.168.1.1 &amp;&gt;/dev/null; then<br>    echo &quot;Host is down&quot;<br>    exit 1<br>fi</pre><p>$? holds the exit code of the last command (0 = success, anything else = failure). You can check it directly:</p><pre>ping -c 1 192.168.1.1<br>if [ $? -ne 0 ]; then<br>    echo &quot;Ping failed&quot;<br>fi</pre><p><strong>6. Trap Errors</strong></p><pre>trap &#39;echo &quot;Error occurred on line $LINENO&quot;&#39; ERR</pre><p>This catches errors and tells you exactly where they happened. Useful for debugging long scripts. I personally prefer using them almost in every script.</p><p><strong>7. Example: Robust Script Template</strong></p><pre>#!/usr/bin/bash<br>set -euo pipefail<br># Trap errors and show line number<br>trap &#39;echo &quot;Error on line $LINENO. Exiting.&quot; &gt;&amp;2&#39; ERR<br># Check if required command exists<br>if ! command -v nmap &amp;&gt;/dev/null; then<br>    echo &quot;nmap is not installed. Install it first.&quot;<br>    exit 1<br>fi<br># Your actual script logic here<br>echo &quot;Script running safely...&quot;</pre><p><strong>Key takeaway:</strong> Always use set -euo pipefail at the top of your scripts unless you have a specific reason not to. It saves you from debugging silent failures later.</p><p>This is all you need to understand for the bash syntax <strong>(for now)</strong>.</p><h3>Module 4: Example and Conclusion</h3><p>I now will show you a simple example, so you can see what goes where:</p><pre>#!/usr/bin/bash<br>set -euo pipefail<br>trap &#39;echo &quot;Error on line $LINENO&quot; &gt;&amp;2&#39; ERR<br># 1. Variables + parameter expansion<br>USER_NAME=&quot;${1:-Martin}&quot;     # default if not provided<br>AGE=17<br>unset TEMP_VAR || true<br># 2. Quoting + command substitution<br>TODAY=&quot;$(date)&quot;<br>echo &quot;User: $USER_NAME&quot;<br>echo &quot;Today is $TODAY&quot;<br>echo &#39;This $WILL not expand&#39;<br># 3. Command chaining<br>mkdir -p demo_dir &amp;&amp; cd demo_dir || exit 1<br># 4. Conditionals<br>if [[ &quot;$USER_NAME&quot; == M* ]]; then<br>    echo &quot;Name starts with M&quot;<br>else<br>    echo &quot;Name does not start with M&quot;<br>fi<br># 5. Loops<br>for i in 1 2 3; do<br>    echo &quot;For loop value: $i&quot;<br>done<br>count=1<br>while (( count &lt;= 2 )); do<br>    echo &quot;While loop count: $count&quot;<br>    ((count++))<br>done<br># 6. Function<br>greet() {<br>    local name=&quot;$1&quot;<br>    echo &quot;Hello, $name&quot;<br>    echo &quot;Args count: $#&quot;<br>}<br>greet &quot;$USER_NAME&quot;<br># 7. Arrays<br>tools=(nmap curl git)<br>echo &quot;First tool: ${tools[0]}&quot;<br>echo &quot;All tools: ${tools[@]}&quot;<br>declare -A person<br>person[name]=&quot;$USER_NAME&quot;<br>person[age]=$AGE<br>echo &quot;Assoc name: ${person[name]}&quot;<br># 8. Redirection + pipes<br>echo &quot;log entry&quot; &gt; output.log<br>ls nonexistent 2&gt; error.log || true<br>cat output.log | grep log &gt; filtered.log<br># 9. String parameter expansion<br>FILE=&quot;report.txt&quot;<br>echo &quot;Filename without ext: ${FILE%.*}&quot;<br>TEXT=&quot;one two one&quot;<br>echo &quot;${TEXT//one/three}&quot;<br># 10. Arithmetic<br>((x = 5 + 3))<br>((x++))<br>y=$((x * 2))<br>echo &quot;Math result: $y&quot;<br># 11. Special variables<br>echo &quot;Script: $0&quot;<br>echo &quot;Args: $@&quot;<br>echo &quot;PID: $$&quot;<br># 12. Manual error check<br>if ! command -v git &amp;&gt;/dev/null; then<br>    echo &quot;git missing&quot;<br>    exit 1<br>fi<br>echo &quot;Script finished cleanly&quot;</pre><p>The output will be:</p><pre>User: Martin<br>Today is Sat Jan 24 02:34:14 PM +04 2026<br>This $WILL not expand<br>Name starts with M<br>For loop value: 1<br>For loop value: 2<br>For loop value: 3<br>While loop count: 1<br>While loop count: 2<br>Hello, Martin<br>Args count: 1<br>First tool: nmap<br>All tools: nmap curl git<br>Assoc name: Martin<br>Filename without ext: report<br>three two three<br>Math result: 18<br>Script: ./test.sh<br>Args: <br>PID: 15634<br>Script finished cleanly</pre><p>You can toy around with this script to understand every part of it.</p><h3>Conclusion</h3><p>Bash is an essential tool in cybersecurity, but we are far from done yet. A real security practitioner must be able to chain tools, automate workflows, and extract maximum value from simple commands. That level comes later.</p><p>The next step is Python. A cybersecurity-focused Python methodology will be released in early February, and after you understand both languages it will be time to combine them by finally writing a program that will be useful as your portfolio project or simply for your personal use. Thank you for your time!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c37d9f2f0098" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/everything-you-need-to-know-about-bash-beginners-guide-part-1-c37d9f2f0098">The Bash Scripting Guide Every Cybersecurity Beginner Needs</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OWASP Juice Shop: Complete 1-Star Challenge Walkthrough]]></title>
            <link>https://osintteam.blog/owasp-juice-shop-complete-1-star-challenge-walkthrough-e0b2bc4ae381?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0b2bc4ae381</guid>
            <category><![CDATA[owasp-juice-shop]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[writeup]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Fri, 23 Jan 2026 12:30:59 GMT</pubDate>
            <atom:updated>2026-01-23T12:30:59.993Z</atom:updated>
            <content:encoded><![CDATA[<h3>OWASP Juice Shop challenges — 1 star difficulty</h3><p>OWASP Juice Shop is arguably one of the if not <strong>THE</strong> best lab for learning web application penetration testing. In this write-up we will be completing OWASP Juice Shop’s 1 star challenges, we will focus on key techniques and detailed explanation of each challenge. Go to /score-board to finish the first challenge and observe others. <strong>This write up will not be including coding challenges</strong>. Without further ado let’s get started!</p><blockquote><strong><em>Important: </em></strong><em>To fully understand this guide it is recommended to have a broad knowledge on Burp Suite and basic security knowledge. You can check my previous articles for this, and hold tight Burp Suite methodology should be out around the same time as this article (probably out already).</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DRTRln8KsG2-3meKGmYjNQ.png" /></figure><h3>Installing and Running The Juice Shop.</h3><h3>OWASP Juice Shop</h3><p>I personally don’t recommend using docker because it blocks some of the challenges, unless we pull some shenanigans. That’s why I will install it using the official git repository.</p><p>First install Node js if you don’t have it.</p><pre>sudo apt install nodejs npm #Debian based Distros<br>sudo dnf install nodejs npm #RedHat based distros<br>sudo pacman -S nodejs npm #Arch based Distros<br><br>node -v #check install<br>npm -v #check install</pre><p>Next thing to do is to get the official repository of Juice Shop.</p><pre>git clone https://github.com/juice-shop/juice-shop.git #The application is pretty big so it might take time<br>cd juice-shop #go into the folder</pre><p>All left to do is install and run the application.</p><pre>npm install #can take up to 5 minutes ignore the warnings about vulnerabilities that&#39;s the point<br>npm start #start the service and go to http://localhost:3000</pre><p>Done!</p><h3>Zero Stars</h3><blockquote>Give a devastating zero-star feedback to the store.</blockquote><p>To do so we first must create an account. The account creation implies that our password should be 5–40 characters. Out of curiosity I decided to try intercept the request and enter 4 characters. And it worked.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uDYWWds33umm8GSNJ1Gz3g.png" /></figure><p>This tells us that the input validation is client side only, aka server trusts client <em>too much, </em>aka it lacks server-side input validation. Keep this in mind for the future. Now back to main task.</p><p>Go to customer feedback page and write a review, then send the review but intercept it with Burp Suite and change the rating in HTTP request to 0. Congrats you succeeded.</p><h3>Bully Chatbot</h3><blockquote><em>Receive a coupon code from the support chatbot.</em></blockquote><p>Go to the Support chat and ask the chatbot to give you the coupon. INSIST on it until he gives up.</p><h3>Error Handling</h3><blockquote><em>Provoke an error that is neither very gracefully nor consistently handled.</em></blockquote><p>The easiest way to do so is to send a malformed review to one of the products. Write anything in the review then intercept it with Burp Suite, after which <em>play with it</em> for example I removed the &quot;&quot; where they were clearly expected.</p><h3>Missing Encoding</h3><blockquote><em>Retrieve the photo of Bjoern’s cat in “melee combat-mode”.</em></blockquote><p>To do so we have to go to the Photo wall and we see the first picture is missing. When we inspect the page source we see this.</p><pre>&lt;img _ngcontent-ng-c1771354057=&quot;&quot; class=&quot;image&quot; src=&quot;assets/public/images/uploads/ᓚᘏᗢ-#zatschi-#whoneedsfourlegs-1572600969477.jpg&quot; alt=&quot;😼 #zatschi #whoneedsfourlegs&quot;&gt;</pre><p>URL encoding uses # for fragment denotation so it does not work here. To fix this, we have to encode it ourselves replace it with %23 (this is the URL encode of the &#39;#&#39;) and done!</p><h3>DOM XSS and Bonus Payload</h3><blockquote><em>Perform a </em>DOM<em> XSS attack with </em><em>&lt;iframe src=&quot;javascript:alert(`xss`)&quot;&gt;.</em></blockquote><p>DOM XSS means <strong>user input is written into the DOM with</strong> <strong>innerHTML</strong> <strong>or similar</strong>, without sanitization. No server needed. For this we will simply input following line inside the app’s search bar And complete the challenge!</p><pre>&lt;iframe src=&quot;javascript:alert(`xss`)&quot;&gt;</pre><p>The next challenge is the same except send the following payload</p><pre>&lt;iframe width=&quot;100%&quot; height=&quot;166&quot; scrolling=&quot;no&quot; frameborder=&quot;no&quot; allow=&quot;autoplay&quot; src=&quot;https://w.soundcloud.com/player/?url=https%3A//api.soundcloud.com/tracks/771984076&amp;color=%23ff5500&amp;auto_play=true&amp;hide_related=false&amp;show_comments=true&amp;show_user=true&amp;show_reposts=false&amp;show_teaser=true&quot;&gt;&lt;/iframe&gt;</pre><p>And enjoy the incredible song.</p><h3>Privacy Policy</h3><blockquote><em>Read our privacy policy.</em></blockquote><p>Just be logged in and go to Account → Privacy and Security → Privacy Policy</p><h3>Web3 Sandbox</h3><blockquote><em>Find an accidentally deployed code sandbox for writing smart contracts on the fly.</em></blockquote><p>Inspect the page and go to <strong>“Sources”</strong>, there you will find main.js file when inspecting it press ctrl + f and search by keywords such as ‘sandbox’ or ‘web3’. The right path for the sandbox is “<a href="http://localhost:3000/#/web3-sandbox">http://localhost:3000/#/web3-sandbox</a>”, after finding the path, enter it in the URL and you’re there.</p><h3>Repetitive Registration</h3><blockquote><em>Follow the DRY principle while registering a user.</em></blockquote><p>Logout from your account and try to register a new one, do everything the way you did before BUT when clicking register intercept the request with Burp Suite and delete the repeated password from your request.</p><h3>Exposed Metrics</h3><blockquote><em>Find the endpoint that serves usage data to be scraped by a </em><a href="https://github.com/prometheus/prometheus"><em>popular monitoring system</em></a><em>.</em></blockquote><p>The popular monitoring system in question is Prometheus. We have to check the official documentation or do a simple google search, and we find out that Prometheus by default keeps metrics at <strong>/metrics</strong> directory. so just access it by going <a href="http://localhost:3000/metrics">http://localhost:3000/metrics</a></p><h3>Outdated Allowlist</h3><blockquote><em>Let us redirect you to one of our crypto currency addresses which are not promoted any longer.</em></blockquote><p>We have to find a link that redirects us <em>somewhere crypto related</em> to do so we should open DevTools again and find the main.js file and inspect it. Press ctrl + f and type ‘redirect’ then try to find links that are crypto related, and look what we’ve got. There are multiple Crypto wallets, the first one I found was ./redirect?to=https://blockchain.info/address/1AbKfgvw9psQ41NbLi8kufDQTezwG8DRZm but there are other cryptos too. Now simply add this URL block to the main domain and go there.</p><h3>Mass Dispel</h3><blockquote><em>Close multiple “Challenge solved”-notifications in one go.</em></blockquote><p>The hint tells us to check the Documentation of the Application, so we do it, and here’s what we find out. You might’ve noticed it already but when we restart the application all the notifications get piled up, and it can get really annoying closing each of them one by one, so the devs help us out by allowing closing all of them with Shift + Left mouse button click. And that is how we complete the challenge.</p><h3>Conclusion</h3><p>1 Star challenges aren’t hard, that’s their point but they told us how application works, and trained our observation so we are ready for harder challenges. In the upcoming days I will upload the write-up of 2 star challenges so follow me to not miss them out! Thank you for your time!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0b2bc4ae381" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/owasp-juice-shop-complete-1-star-challenge-walkthrough-e0b2bc4ae381">OWASP Juice Shop: Complete 1-Star Challenge Walkthrough</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Swiss Knife of the Pen-Tester, Practical Burp Suite Methodology — Part 1]]></title>
            <link>https://osintteam.blog/swiss-knife-of-the-pen-tester-practical-burp-suite-methodology-part-1-7df3f88fa024?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/7df3f88fa024</guid>
            <category><![CDATA[red-team]]></category>
            <category><![CDATA[burpsuite]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Thu, 22 Jan 2026 02:04:30 GMT</pubDate>
            <atom:updated>2026-01-22T02:04:30.726Z</atom:updated>
            <content:encoded><![CDATA[<h3>Swiss Knife of the Pen-Tester, Practical Burp Suite Methodology — Part 1</h3><h3>Getting started with Burp Suite</h3><p>Burp Suite is a core offensive security platform used for manual web application testing. Here I will document Burp , focusing on request analysis, attack surface discovery, and exploit development rather than automated scanning. For our target we will use DVWA (Damn Vulnerable Web Application). Check official repository if you’re interested — <a href="https://github.com/digininja/DVWA">https://github.com/digininja/DVWA</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I2biaF_sjKQdPSdzn-oHiA.png" /></figure><blockquote><strong><em>IMPORTANT:</em></strong><em> This write up is NOT a documentation and is not supposed to teach you every function of the tool, it is supposed to be showing actual Red Team methodology using Burp Suite, if your aim is to learn the tool specifically, it’s recommended to use the actual documentation of the tool </em><a href="https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-excessive-trust-in-client-side-controls"><em>Portswigger guide</em></a><em>.</em></blockquote><h3>Intercepting a request</h3><p>We will use Burp Proxy to intercept requests. Burp Proxy allows interception and modification of HTTP requests in transit, enabling visibility into parameters, headers, cookies, and server trust assumptions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0TUnypLc5Lj0s6dBNuRyow.png" /></figure><p>Click the Proxy tab then turn on the intercept. You will see the image in the middle say “Intercept is on”. Now every request performed by Burps browser will be shown here. Click “Open Browser” to open Chromium — Burp Suite’s built-in browser, it is preconfigured to work with with Burp Suite.</p><p>When we send a HTTP request Burp Suite will intercept it so the page won’t load, and we can study the request.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ec573bJWnrz3om86GUg9vQ.png" /></figure><p>Now we can study the request, and even <strong>modify</strong> it. We can see that currently it’s in <strong>pretty</strong> mode, but there are also Raw and Hex versions. So the request gets to the server we have to click forward. Logically you won’t need to intercept every request so turn it off when you don’t need it. Next to Intercept tab there’s also <strong>HTTP history tab</strong> that we can use to check requests and responses that we already did.</p><blockquote><strong><em>NOTE:</em></strong><em> At this stage, no exploitation is performed. The goal is to understand request structure, flow, and server responses before attempting manipulation.</em></blockquote><p><strong>What browsers hide:</strong></p><p>When you click “login” in a browser, this happens invisibly:</p><ol><li>JavaScript may modify your input</li><li>Hidden fields are added</li><li>Headers are automatically set</li><li>Request is sent</li></ol><p><strong>You never see:</strong></p><ul><li>What data is actually being sent</li><li>Which fields are validated client-side only</li><li>What the server actually receives</li></ul><p><strong>Burp reveals this:</strong></p><pre>POST /login.php HTTP/1.1<br>Host: localhost:8081<br>Content-Type: application/x-www-form-urlencoded<br>username=admin&amp;password=password&amp;user_token=abc123&amp;Login=Login</pre><p><strong>Security implications:</strong></p><ul><li>user_token is a CSRF token - can we bypass it?</li><li>Login=Login is a hidden field - is it validated?</li><li>Client-side JavaScript might reject input — but will backend do so too?</li></ul><p><strong>Attack surface questions:</strong></p><ul><li>What happens if I remove user_token?</li><li>What if I change Login to something else?</li><li>What if I add extra parameters?</li></ul><h3>Modifying HTTP requests with Burp Proxy</h3><p>Now we will manipulate these requests in ways that the website isn’t expecting, in order to see how it responds.</p><p>In this technical write up we will focus on understanding the topic and develop a mindset of a Red Team.</p><p><strong>Login:</strong></p><p>Go back to <a href="http://localhost:8081/login.php">http://localhost:8081/login.php</a> and turn <strong>intercept</strong> on. Now click login again.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lK8jMq63a-GGwYqemXoJyw.png" /></figure><p>Using the previously identified login request, we now manipulate parameters to observe backend validation behavior. After doing so go to <strong>HTTP history</strong> and pick your request to see information about it and the response. <em>Don’t forget to switch the “Original request” to “Edited request” to look at right thing.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qMevI9twL8cXSxnryVTzJw.png" /></figure><p>When we change the username or the password to wrong one we receive code 302 which redirects us back to login page. In addition if we change the <strong>user_token</strong> we will also see that original body of the login page has changed, it now has following lines.</p><pre>&lt;div class=&quot;message&quot;&gt;CSRF token is incorrect&lt;/div&gt;</pre><p>This confirms that DVWA enforces CSRF protection on the login endpoint and validates the token before credential processing. Authentication failure and CSRF failure are handled as separate conditions, each producing distinct server responses. Now you know how to modify requests in Burp Suite.</p><blockquote><strong><em>TIP:</em></strong></blockquote><blockquote><em>HTTP History tab will be saving all the requests that happened in the browser including third party requests like Google Analytics, etc. They add noise and make our job harder, To prevent that add the Hosts of interest to </em><strong><em>scope</em></strong><em>. To do so, keep clicking the header of the leftmost column (#) until the requests are sorted in descending order (to see the latest requests) then right click on the request and click </em><strong><em>“Add to scope”</em></strong><em>. You can manage the scope by going to </em><strong><em>Target &gt; Site map</em></strong><em>.</em></blockquote><h3>Reissue requests with Burp Repeater</h3><p>In this section we will be using <strong>Burp Repeater</strong> to send an <em>interesting request</em> over and over again. This will allow us to study server response to different input without having to constantly use intercept every single request. We will dissect DVWA login page to determine how does CSRF token work in that application <em>exactly</em>.</p><h4>Step 1: Identify an interesting request</h4><p>An interesting request can be anything depending on the application, sometimes it’s about a certain product like GET /product request with a productId query parameter or it can be related to the login, etc.</p><p>For us the interesting request is the POST request that’s being sent by the client to the server to login to the application</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EVwpAYNDe3Jud6wBdlpkow.png" /></figure><p>Right click on it and click “Send to Repeater” The repeater tab will start blooming you can see your request there.</p><h4>Step 2: Understand how Repeater works</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0_49NkXXjPzdUfNvOpznKA.png" /></figure><p>Here we see our request let’s first send the original version, it will give us status 302 which means we’re being redirected, next to send button “Follow redirection” button will appear, click it. after that we see the response confirming we are in index.php (this is the Home of the DVWA)</p><pre>HTTP/1.1 200 OK<br>Date: Thu, 08 Jan 2026 11:02:52 GMT<br>Server: Apache/2.4.25 (Debian)<br>Expires: Tue, 23 Jun 2009 12:00:00 GMT<br>Cache-Control: no-cache, must-revalidate<br>Pragma: no-cache<br>Vary: Accept-Encoding<br>Content-Length: 6864<br>Keep-Alive: timeout=5, max=100<br>Connection: Keep-Alive<br>Content-Type: text/html;charset=utf-8<br><br>&lt;!DOCTYPE html PUBLIC &quot;-//W3C//DTD XHTML 1.0 Strict//EN&quot; &quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd&quot;&gt;<br>&lt;html xmlns=&quot;http://www.w3.org/1999/xhtml&quot;&gt;<br> &lt;head&gt;<br>  &lt;meta http-equiv=&quot;Content-Type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;<br>  &lt;title&gt;Welcome :: Damn Vulnerable Web Application (DVWA) v1.10 *Development*&lt;/title&gt;<br>  &lt;link rel=&quot;stylesheet&quot; type=&quot;text/css&quot; href=&quot;dvwa/css/main.css&quot; /&gt;<br>  &lt;link rel=&quot;icon&quot; type=&quot;\image/ico&quot; href=&quot;favicon.ico&quot; /&gt;<br>  &lt;script type=&quot;text/javascript&quot; src=&quot;dvwa/js/dvwaPage.js&quot;&gt;&lt;/script&gt;<br> &lt;/head&gt;<br> &lt;body class=&quot;home&quot;&gt;<br> ...</pre><p>Now we can resend this request as many times as we like and response will be new every time. Next to the same “Send” button click “&lt;” to go back to our original request since it changed because of the redirection and session/cookie assignment.</p><h4>Step 3: Modify the request in Repeater</h4><p>Finally we will edit the request to try different case scenarios to understand how the server works with CSRF tokens.</p><h4>Case 1 — Missing token:</h4><p>Edit the request like you did before and hit send → follow redirect like i showed earlier. We still receive status code 302 BUT this time we’re sent back to /login.php with the response body containing &lt;div class=&quot;message&quot;&gt;CSRF token is incorrect&lt;/div&gt;.</p><h4>Case 2 — Wrong Token (Discussed previously):</h4><p>After we send wrong token we receive the exact same response. Also interesting to point out that in the response body we can see a different CSRF token from the original one (happens every time), if we try that one we will still receive incorrect token message. <em>Interesting.</em></p><h4>Case 3 — Malformed Token:</h4><p>How about we don’t send just wrong token but a malformed one? I will use Chinese, Arabic Cyrillic letters and non ASCII symbols. In Burp those symbols will be rectangles or “?” that is not an error on your side Burp simply can’t show it to you because it lacks fonts. The server response remains unchanged, indicating that CSRF validation is not influenced by character encoding or token format.</p><p>Browsers default to UTF-8 and server <strong>expects it</strong> but it’s not enforced. What if we change the encoding? To do so let’s lie to the header and resend our malformed request.</p><p>Content-Type: application/x-www-form-urlencoded; charset=ISO-8859-1. The key parts of the response are:</p><pre>HTTP/1.1 200 OK<br>Date: Thu, 08 Jan 2026 11:28:37 GMT<br>Server: Apache/2.4.25 (Debian)<br>Expires: Tue, 23 Jun 2009 12:00:00 GMT<br>Cache-Control: no-cache, must-revalidate<br>Pragma: no-cache<br>Vary: Accept-Encoding<br>Content-Length: 1735<br>Keep-Alive: timeout=5, max=100<br>Connection: Keep-Alive<br>Content-Type: text/html;charset=utf-8 &lt;!--Server enforces UTF 8--&gt;<br><br>&lt;!DOCTYPE html PUBLIC &quot;-//W3C//DTD XHTML 1.0 Strict//EN&quot; &quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd&quot;&gt;<br>&lt;html xmlns=&quot;http://www.w3.org/1999/xhtml&quot;&gt;<br>...<br><br> &lt;div class=&quot;message&quot;&gt;You have logged in as &#39;admin&#39;&lt;/div&gt;<br> &lt;div class=&quot;message&quot;&gt;You have logged in as &#39;admin&#39;&lt;/div&gt;<br> &lt;div class=&quot;message&quot;&gt;CSRF token is incorrect&lt;/div&gt;<br> &lt;div class=&quot;message&quot;&gt;CSRF token is incorrect&lt;/div&gt;<br>...<br>&lt;/html&gt;</pre><p>Although the application does not redirect to the authenticated area, the presence of the ‘You have logged in as admin’ message confirms that authentication logic executed successfully and a session was established. Which means: <strong>Authentication happens before CSRF token validation</strong>. But why do we receive each message twice? This is the result of sloppiness of the “low” difficulty. The application processes authentication and CSRF validation without enforcing a strict execution order or terminating request processing on failure. As a result, both success and failure messages are generated and rendered multiple times within a single response.</p><p>Now let’s check whether the server has proper input-handling, aka we will poke the server’s decoding to see if it has holes of its own. To do this we will try <strong>Raw Binary Abuse</strong>. To do so in the Repeater, when editing the request change the ‘Pretty’ presentation to ‘Raw’. Important to note that this technique will work best if the backend has C, C++ extensions, Legacy libraries or Mixed language stacks. It’s not DVWA’s case the technique remains valid for other applications.</p><p><strong>Case 3.1 Null Byte injection:</strong></p><p>This will tell us whether the backend treats %00 as string terminator.</p><p>For example let’s use: user_token=abc%00def. Now the response body contains 2 &quot;CSRF token is incorrect&quot; messages again, which we already discussed. Note no auth this time.</p><p><strong>Case 3.2 Invalid UTF‑8 sequences:</strong></p><p>Sometimes this can cause a crash if parser is <em>really bad</em>. We will use user_token=%C0%AF. This time no interesting response was received.</p><p><strong>Case 3.3 Control Characters:</strong></p><p>ASCII control characters are <strong>still</strong> ASCII but <em>different</em>. user_token=abc%0D%0Adef. This is CRLF Response is the same.</p><blockquote>Note:</blockquote><blockquote>(The term CRLF refers to <strong>Carriage Return (ASCII 13, \r ) Line Feed (ASCII 10, \n )</strong>. They’re used to note the termination of a line, however, dealt with differently in today’s popular Operating Systems.)</blockquote><p><strong>Case 3.4 Size mismatch:</strong></p><p>Here we will try to <strong>lie</strong> about the size of our content. Set Content-Length header to 1. Note that this is more effective in raw sockets, Burp Suite won’t allow us to fully desync HTTP easily. Response is <strong>double</strong> message about CSRF token being incorrect.</p><p><strong>Observations Summary</strong></p><ul><li>CSRF token presence and value are validated, but validation does not block authentication logic.</li><li>Character encoding manipulation does not influence CSRF validation.</li><li>Malformed, binary, and control-character input is normalized before validation.</li><li>No decoding or parsing vulnerabilities were identified.</li><li>Authentication executes prior to CSRF enforcement on low security configuration.</li></ul><h3>Conclusion and Tips</h3><p>These were specific examples, but there are <strong>unwritten rules</strong> when we analyse server behavior through HTTP Requests:</p><h4>HTTP status codes:</h4><p>These are crucial for understanding backend logic.</p><ul><li><strong>200</strong> → action likely succeeded or app failed open</li><li><strong>302 / 301</strong> → redirect, often auth or validation failure</li><li><strong>401 / 403</strong> → access control triggered</li><li><strong>400</strong> → input rejected early</li><li><strong>500</strong> → you broke backend logic (valuable)</li></ul><h4>Response body differences:</h4><p>You don’t need to check the whole response.</p><ul><li>New error message?</li><li>Different HTML block?</li><li>Debug output?</li><li>Same page but different content?</li></ul><p><strong>Example we already saw:</strong></p><ul><li>Invalid CSRF → explicit CSRF error</li><li>Invalid credentials → generic login failure</li></ul><h4>Authentication state changes:</h4><p>After forwarding a modified request, ask:</p><ol><li>Am I still logged in?</li><li>Was I logged out?</li><li>Did my role change?</li><li>Did access persist?</li></ol><h4>Headers:</h4><p>For example Set-Cookie can appear in <strong>failed auth responses</strong> too. Pay attention to</p><ul><li><strong>Is it a NEW session token?</strong> (auth succeeded)</li><li><strong>Is it the SAME token?</strong> (auth failed, session persisted)</li><li><strong>Is the token DELETED?</strong> (session terminated)</li></ul><ol><li>Other headers can give interesting information too.</li><li><strong>What the server ignores:</strong></li><li>Sometimes <em>nothing</em> can be more useful than <em>something</em></li></ol><ul><li>Duplicate parameters (which one wins?)</li><li>Case sensitivity in parameter names</li><li>Content-Type manipulation (JSON → form-data → XML)</li><li>HTTP verb changes (POST → PUT → PATCH)</li></ul><p>Thanks to these you will be able to build a <strong>mental security map.</strong> Use this structure mentally or make your own:</p><ol><li><strong>Entry points:</strong> <strong>Login, Settings, Forms, API endpoints</strong> — anything that changes state</li><li><strong>For each entry point answer 4 questions:</strong></li><li>What controls access? <strong>Session cookie, Token, Role, Nothing</strong>?</li><li>What validation exists? <strong>CSRF, Input length, Method check, Client-side only</strong>?</li><li>What happens if input lies? <strong>Silent fail, Explicit error, Partial Success</strong>?</li><li>What does the server trust by default? This is a crucial one.</li></ol><p>In the next Burp-Suite Methodology tradecrafts we will focus on more offensive techniques.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7df3f88fa024" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/swiss-knife-of-the-pen-tester-practical-burp-suite-methodology-part-1-7df3f88fa024">Swiss Knife of the Pen-Tester, Practical Burp Suite Methodology — Part 1</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Practical cURL Methodology for Security Testing — Part 1: Observation]]></title>
            <link>https://osintteam.blog/a-practical-curl-methodology-for-security-testing-part-1-observation-570a43fee895?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/570a43fee895</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[red-team-methodology]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[curl]]></category>
            <category><![CDATA[information-security]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Tue, 13 Jan 2026 02:33:55 GMT</pubDate>
            <atom:updated>2026-01-13T02:33:55.940Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>A Practical cURL Methodology for Security Testing — Part 1:</strong> Observation</h3><h3>A Practical Guide to Network Analysis for Security Testing</h3><p>This guide documents cURL techniques for authorized security testing and penetration testing. I developed this methodology while practicing on intentionally vulnerable applications like DVWA and controlled testing environments. This is for security professionals, bug bounty hunters, and students learning offensive security for defensive purposes.</p><blockquote><strong><em>Important:</em></strong><em> You must have explicit authorization before testing any system. This guide assumes you have DVWA or an equivalent vulnerable application installed for practice.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V7wXKPeGt3OucC-zUxRa7Q.png" /></figure><h4>Understanding cURL as a Protocol Speaker</h4><p>cURL is fundamentally a protocol speaker. It connects to (IP, port) and speaks whatever the URL scheme dictates. The connection and request lifecycle follows this pattern:</p><p><strong>DNS → TCP → Protocol → Application</strong></p><p>When troubleshooting, always trace through this sequence systematically.</p><h3>Module 0: Setup and Reconnaissance</h3><p>Before diving into testing, we need to understand what our cURL installation is capable of. This step is often skipped, but it’s critical for effective reconnaissance.</p><h3>Understanding Your cURL Installation</h3><p>Start by examining your cURL version and capabilities:</p><pre>curl --version</pre><p>Output:</p><pre>curl 8.11.1 (x86_64-redhat-linux-gnu) libcurl/8.11.1 OpenSSL/3.2.6 zlib/1.3.1.zlib-ng brotli/1.2.0 libidn2/2.3.8 libpsl/0.21.5 libssh/0.11.3/openssl/zlib nghttp2/1.64.0 OpenLDAP/2.6.10<br>Release-Date: 2024-12-11<br>Protocols: dict file ftp ftps gopher gophers http https imap imaps ipfs ipns ldap ldaps mqtt pop3 pop3s rtsp scp sftp smb smbs smtp smtps telnet tftp ws wss<br>Features: alt-svc AsynchDNS brotli GSS-API HSTS HTTP2 HTTPS-proxy IDN IPv6 Kerberos Largefile libz NTLM PSL SPNEGO SSL threadsafe TLS-SRP UnixSockets</pre><p>As you could have guessed I’m using Fedora Linux</p><h3>Why did this give us?</h3><p><strong>1. Version Information</strong></p><p>I’m running cURL 8.11.1, released December 11, 2024. Version matters because:</p><ul><li>Behavior changes between versions</li><li>Flags appear and disappear over time</li><li>TLS defaults evolve</li><li>When something behaves differently on another system, version is your first troubleshooting checkpoint</li></ul><p><strong>2. Protocol Support</strong></p><p>My cURL supports: <strong>dict, file, ftp, ftps, gopher, gophers, http, https, imap, imaps, ipfs, ipns, ldap, ldaps, mqtt, pop3, pop3s, rtsp, scp, sftp, smb, smbs, smtp, smtps, telnet, tftp, ws, wss</strong></p><p>This list defines the attack surface cURL can reach from this machine. Each protocol is a potential testing vector.</p><p><strong>3. Feature Capabilities</strong></p><p>The features list tells us whether specific checks will work. For example, if you don’t have IPv6 support, IPv6 testing won’t work. We’re mapping attack surface and capabilities systematically.</p><h3>Module 1: Foundations of Web Request Analysis</h3><p>In this module we’ll fetch pages, analyze headers, and troubleshoot failures at each layer.</p><h4>Quick Note:</h4><p>Before we proceed, two concepts you should know to understand coming material:</p><p><strong>stdout (Standard Output):</strong> The default output stream where programs display results.</p><p><strong>stderr (Standard Error):</strong> A separate stream for error messages and diagnostic information.</p><p>We’ll capture both using 2&gt;&amp;1 in our commands.</p><h4>Basic Page Retrieval</h4><p>Fetch HTML content from a web server:</p><pre>curl &quot;https://httpbin.org&quot;</pre><p>The HTML prints to stdout. Simple first step.</p><h4>Protocol Comparison: HTTP/1.1 vs HTTP/2</h4><p>Force specific HTTP versions and compare their differences using verbose mode:</p><pre>curl --http1.1 -v https://httpbin.org/ &gt;&gt; http1.1.txt 2&gt;&amp;1<br>curl --http2 -v https://httpbin.org/ &gt;&gt; http2.txt 2&gt;&amp;1</pre><p>The 2&gt;&amp;1 captures both stdout and stderr for complete diagnostics.</p><p>Compare the outputs:</p><pre>diff http1.1.txt http2.txt</pre><p>Key differences I found:</p><pre>&lt; * ALPN: curl offers http/1.1<br>---<br>&gt; * ALPN: curl offers h2,http/1.1<br>&lt; * ALPN: server accepted http/1.1<br>---<br>&gt; * ALPN: server accepted h2<br>&lt; * using HTTP/1.x<br>---<br>&gt; * using HTTP/2<br>&lt; &gt; GET / HTTP/1.1<br>---<br>&gt; &gt; GET / HTTP/2</pre><p>Even when the response body is identical, verbose logs reveal protocol negotiation, server selection, and framing differences. These details matter for security testing.</p><h4>Security Header Analysis</h4><p>Headers reveal what the server exposes by default and what it forgot to hide. Extract headers using the -I flag:</p><pre>curl -I https://httpbin.org</pre><p>Output:</p><pre>HTTP/2 200 <br>date: Sat, 03 Jan 2026 17:51:15 GMT<br>content-type: text/html; charset=utf-8<br>content-length: 9593<br>server: gunicorn/19.9.0<br>access-control-allow-origin: *<br>access-control-allow-credentials: true</pre><p>These headers show what protection mechanisms are present or absent.</p><h4>Response Differential Analysis</h4><p>Understanding how servers react to both successful and failed requests is essential:</p><pre>curl -v https://httpbin.org &gt;&gt; 200.txt 2&gt;&amp;1<br>curl -v https://httpbin.org/nonexistingdirectory321 &gt;&gt; 404.txt 2&gt;&amp;1</pre><p>Comparing these responses reveals error message verbosity, header differences, and information disclosure patterns. (run the <strong>diff</strong> again.)</p><h3>Module 2: Verbose Diagnostics and Connection Troubleshooting</h3><p>Reading verbose output is a critical skill. We’ll troubleshoot each layer of the connection and request lifecycle.</p><h4>Layer 1: DNS Failure</h4><pre>curl -v http://nonexistent.example/</pre><p>Output:</p><pre>* Could not resolve host: nonexistent.example<br>* shutting down connection <br>curl: (6) Could not resolve host: nonexistent.example</pre><p>The operation stops immediately at DNS resolution. No TCP connection is attempted.</p><h4>Layer 2: TCP Timeout</h4><p>Test with an unreachable host:</p><pre>curl -v http://10.255.255.1/</pre><p>Output:</p><pre>*   Trying 10.255.255.1:80...<br>* connect to 10.255.255.1 port 80 from 192.168.15.9 port 52694 failed: Connection timed out<br>* Failed to connect to 10.255.255.1 port 80 after 134377 ms: Could not connect to server<br>* closing connection #0<br>curl: (28) Failed to connect to 10.255.255.1 port 80 after 134377 ms: Could not connect to server</pre><p>DNS resolution isn’t needed since we’re using an IP directly. The timeout occurs at the TCP layer after multiple minutes.</p><p>Another example showing IP fallback behavior:</p><pre>curl -v https://httpbin.org:8000/</pre><p>Output:</p><pre>* Host httpbin.org:8000 was resolved.<br>* IPv6: (none)<br>* IPv4: 98.85.201.92, 44.209.11.94, 52.72.212.236, 52.55.226.129, 54.158.135.159, 54.205.230.94 <br>*   Trying 98.85.201.92:8000...<br>* connect to 98.85.201.92 port 8000 from 192.168.15.9 port 39202 failed: Connection timed out<br>*   Trying 44.209.11.94:8000...</pre><p>cURL cycles through every resolved IP address until one succeeds or all fail.</p><h4>Layer 3: Successful Connection Deep Dive</h4><p>Understanding a successful connection requires parsing each step:</p><pre>curl -v https://httpbin.org</pre><p>Annotated output:</p><pre>* Host httpbin.org:443 was resolved.          # DNS resolution succeeded<br>* IPv6: (none)<br>* IPv4: 52.72.212.236, 54.158.135.159, 98.85.201.92, 52.55.226.129, 54.205.230.94, 44.209.11.94<br>*   Trying 52.72.212.236:443...<br>* ALPN: curl offers h2,http/1.1               # ALPN negotiation begins after TCP succeeds<br>* TLSv1.3 (OUT), TLS handshake, Client hello (1):  # TLS handshake initiated<br>*  CAfile: /etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem<br>*  CApath: none<br>* TLSv1.3 (IN), TLS handshake, Server hello (2):<br>* TLSv1.2 (IN), TLS handshake, Certificate (11):   # Negotiated to TLS 1.2<br>* TLSv1.2 (IN), TLS handshake, Server key exchange (12):<br>* TLSv1.2 (IN), TLS handshake, Server finished (14):<br>* TLSv1.2 (OUT), TLS handshake, Client key exchange (16):<br>* TLSv1.2 (OUT), TLS change cipher, Change cipher spec (1):<br>* TLSv1.2 (OUT), TLS handshake, Finished (20):<br>* TLSv1.2 (IN), TLS handshake, Finished (20):      # TLS handshake complete<br>* SSL connection using TLSv1.2 / ECDHE-RSA-AES128-GCM-SHA256 / secp256r1 / rsaEncryption<br>* ALPN: server accepted h2                          # HTTP/2 selected<br>* Server certificate:                                # Certificate validation<br>*  subject: CN=httpbin.org<br>*  start date: Jul 20 00:00:00 2025 GMT<br>*  expire date: Aug 17 23:59:59 2026 GMT<br>*  subjectAltName: host &quot;httpbin.org&quot; matched certs &quot;httpbin.org&quot; <br>*  issuer: C=US; O=Amazon; CN=Amazon RSA 2048 M03<br>*  SSL certificate verify ok.<br>*   Certificate level 0: Public key type RSA (2048/112 Bits/secBits), signed using sha256WithRSAEncryption<br>*   Certificate level 1: Public key type RSA (2048/112 Bits/secBits), signed using sha256WithRSAEncryption<br>*   Certificate level 2: Public key type RSA (2048/112 Bits/secBits), signed using sha256WithRSAEncryption<br>* Connected to httpbin.org (52.72.212.236) port 443  # Connection confirmed<br>* using HTTP/2<br>* [HTTP/2] [1] OPENED stream for https://httpbin.org/<br>* [HTTP/2] [1] [:method: GET]<br>* [HTTP/2] [1] [:scheme: https]<br>* [HTTP/2] [1] [:authority: httpbin.org]<br>* [HTTP/2] [1] [:path: /]<br>* [HTTP/2] [1] [user-agent: curl/8.11.1]<br>* [HTTP/2] [1] [accept: */*]<br>&gt; GET / HTTP/2                                      # Request sent<br>&gt; Host: httpbin.org<br>&gt; User-Agent: curl/8.11.1<br>&gt; Accept: */*<br>&gt; <br>* Request completely sent off<br>&lt; HTTP/2 200                                        # Response received<br>&lt; date: Sun, 04 Jan 2026 09:18:14 GMT<br>&lt; content-type: text/html; charset=utf-8<br>&lt; content-length: 9593<br>&lt; server: gunicorn/19.9.0<br>&lt; access-control-allow-origin: *<br>&lt; access-control-allow-credentials: true<br>&lt; <br>&lt;!DOCTYPE html&gt;                                     # Response body begins<br>&lt;html lang=&quot;en&quot;&gt;<br>...</pre><p>Mixed TLS version lines can appear in verbose output due to handshake internals and compatibility behavior. This is normal.</p><h3>Module 3: Response Analysis for Security Testing</h3><p>Response analysis is where we move from theory to practical security testing. I’ll demonstrate with real examples.</p><h4>Practical Example: DVWA Login Flow</h4><p>Browsers maintain session state automatically. cURL doesn’t. To authenticate with DVWA, we need to manually manage cookies and CSRF tokens.</p><p><strong>Step 1: Extract CSRF Token</strong></p><pre>curl -c cookies.txt -s http://localhost:8081/login.php -o login.html<br>grep user_token login.html</pre><p>Output shows the hidden CSRF token:</p><pre>&lt;input type=&#39;hidden&#39; name=&#39;user_token&#39; value=&#39;8b9d5057c79412598b062e9aa28c93ea&#39; /&gt;</pre><p><strong>Step 2: Authenticate with Token</strong></p><pre>curl -c cookies.txt -b cookies.txt \<br>-d &quot;username=admin&amp;password=password&amp;Login=Login&amp;user_token=8b9d5057c79412598b062e9aa28c93ea&quot; \<br>http://localhost:8081/login.php -o /dev/null</pre><p><strong>Step 3: Access Protected Resources</strong></p><pre>curl -b cookies.txt http://localhost:8081/index.php</pre><p>Now we have authenticated access for security testing.</p><h4>Section 1: HTTP Status Codes as Behavioral Signals</h4><p>Status codes reveal how the server processed your request and where vulnerabilities might exist.</p><h4>200 OK: Success or Silent Failure</h4><pre>curl -I https://httpbin.org/status/200</pre><p><strong>Security Implications:</strong></p><ul><li>200 on authentication bypass attempt = potential vulnerability</li><li>200 with empty or unexpected body = logic flaw</li><li>200 when expecting 403/401 = broken access control</li></ul><p><strong>Test Pattern:</strong></p><pre># Test admin endpoint access<br>curl -I https://target.com/admin<br># If 200 instead of 403 → broken authorization</pre><pre># Test invalid input handling<br>curl -I &quot;https://target.com/api?id=../../etc/passwd&quot;<br># If 200 instead of 400 → input validation missing</pre><h4>302/301: Redirects</h4><pre>curl -I https://httpbin.org/redirect/1</pre><p><strong>Security Implications:</strong></p><ul><li>Redirect to login = you hit a protected resource</li><li>Redirect with Set-Cookie = session state changed</li><li>Location header content = potential open redirect vulnerability</li></ul><p><strong>Test Pattern:</strong></p><pre># Check authentication redirect behavior<br>curl -I http://localhost:8081</pre><p>Output:</p><pre>HTTP/1.1 302 Found<br>Date: Wed, 07 Jan 2026 05:43:42 GMT<br>Server: Apache/2.4.25 (Debian)<br>Set-Cookie: PHPSESSID=cdcups8atl3ncoj2rqus7hprq5; path=/<br>Expires: Thu, 19 Nov 1981 08:52:00 GMT<br>Cache-Control: no-store, no-cache, must-revalidate<br>Pragma: no-cache<br>Set-Cookie: PHPSESSID=cdcups8atl3ncoj2rqus7hprq5; path=/<br>Set-Cookie: security=low<br>Location: login.php<br>Content-Type: text/html; charset=UTF-8</pre><p>This redirect to login.php is hardcoded, making redirect manipulation impossible here.</p><p><strong>Testing for Open Redirect:</strong></p><pre>curl -I &quot;https://target.com/login?redirect=https://evil.com&quot;</pre><p>Note that the redirect parameter doesn’t have to be named “redirect.” Common alternatives include: next, url, return, dest, continue. Test all variants systematically.</p><p><strong>Practical Example:</strong></p><pre>curl -IL &quot;https://httpbin.org/redirect-to?url=https://google.com&quot;</pre><p>Output shows the redirect chain:</p><pre>HTTP/2 302                                # Initial redirect<br>date: Wed, 07 Jan 2026 08:10:16 GMT<br>content-type: text/html; charset=utf-8<br>content-length: 0<br>location: https://google.com<br>server: gunicorn/19.9.0<br>access-control-allow-origin: *<br>access-control-allow-credentials: true</pre><pre>HTTP/2 301                                # Permanent redirect<br>location: <a href="https://www.google.com/">https://www.google.com/</a><br>content-type: text/html; charset=UTF-8<br>...</pre><pre>HTTP/2 200                                # Final destination<br>content-type: text/html; charset=ISO-8859-1<br>...</pre><h4>401 vs 403: Authentication vs Authorization</h4><pre>curl -I &quot;https://httpbin.org/status/401&quot;</pre><p>Output:</p><pre>HTTP/2 401 <br>date: Wed, 07 Jan 2026 07:53:26 GMT<br>content-length: 0<br>server: gunicorn/19.9.0<br>www-authenticate: Basic realm=&quot;Fake Realm&quot;<br>access-control-allow-origin: *<br>access-control-allow-credentials: true</pre><pre>curl -I &quot;https://httpbin.org/status/403&quot;</pre><p>Output:</p><pre>HTTP/2 403 <br>date: Wed, 07 Jan 2026 07:52:55 GMT<br>content-type: text/html; charset=utf-8<br>content-length: 0<br>server: gunicorn/19.9.0<br>access-control-allow-origin: *<br>access-control-allow-credentials: true</pre><p><strong>The Distinction:</strong></p><ul><li><strong>401 = “I don’t know who you are”</strong> (authentication failure)</li><li><strong>403 = “I know who you are, but you can’t do this”</strong> (authorization failure)</li></ul><p><strong>Security Implications:</strong></p><ul><li>401 → adding authentication might grant access</li><li>403 → you’re authenticated but lacking permission (IDOR testing target)</li><li>403 on one method, try another (GET → POST → PUT)</li></ul><p><strong>IDOR Test Pattern:</strong></p><pre># No authentication<br>curl -I https://target.com/api/users/123<br># Response: 401</pre><pre># With authentication<br>curl -I -H &quot;Authorization: Bearer TOKEN&quot; <a href="https://target.com/api/users/123">https://target.com/api/users/123</a><br># Response: 403 → authorization check exists</pre><pre># Try different user ID<br>curl -I -H &quot;Authorization: Bearer TOKEN&quot; <a href="https://target.com/api/users/456">https://target.com/api/users/456</a><br># Response: 200 → IDOR vulnerability confirmed</pre><h4>400: Bad Request</h4><pre>curl -I &quot;https://httpbin.org/status/400&quot;</pre><p><strong>Security Implications:</strong></p><ul><li>400 = validation exists (good security practice)</li><li>What exactly is being validated? Test variations</li><li>Does it validate everything or just certain fields?</li></ul><p><strong>Test Pattern:</strong></p><pre># Malformed JSON<br>curl -X POST -d &quot;not-json&quot; https://target.com/api</pre><pre># Missing required field<br>curl -X POST -d &#39;{&quot;username&quot;:&quot;test&quot;}&#39; <a href="https://target.com/api">https://target.com/api</a></pre><pre># Type mismatch<br>curl -X POST -d &#39;{&quot;age&quot;:&quot;not-a-number&quot;}&#39; <a href="https://target.com/api">https://target.com/api</a></pre><h4>500: Internal Server Error</h4><pre>curl -I https://httpbin.org/status/500</pre><p>Output:</p><pre>HTTP/2 500 <br>date: Wed, 07 Jan 2026 08:23:01 GMT<br>content-type: text/html; charset=utf-8<br>content-length: 0<br>server: gunicorn/19.9.0<br>access-control-allow-origin: *<br>access-control-allow-credentials: true</pre><p><strong>Why 500 Errors Are Valuable:</strong></p><ul><li>Your input broke something</li><li>Backend exception occurred</li><li>This means input reached backend logic</li></ul><p><strong>Security Implications:</strong></p><ul><li>Input reached backend processing</li><li>Potential injection point discovered</li><li>Error might leak information</li></ul><p><strong>Test Pattern:</strong></p><pre># SQL injection attempt<br>curl &quot;https://target.com/search?q=test&#39;&quot;<br># Response: 500 → query reached database</pre><pre># Path traversal<br>curl &quot;https://target.com/file?path=../../../../etc/passwd&quot;<br># Response: 500 → file operation attempted</pre><pre># Check response body for stack traces<br>curl -v &quot;https://target.com/search?q=test&#39;&quot; 2&gt;&amp;1 | grep -i &quot;error\|exception\|stack&quot;</pre><h4>Section 2: Security Headers Audit</h4><p>Missing security headers expose attack surface. Let me show you what to look for.</p><p><strong>Testing DVWA:</strong></p><pre>curl -I http://localhost:8081</pre><p>Output:</p><pre>Server: Apache/2.4.25 (Debian)<br>X-Powered-By: PHP/7.0.33<br>Set-Cookie: PHPSESSID=abc; path=/<br>Set-Cookie: security=low</pre><p><strong>Security Issues Identified:</strong></p><ol><li>Server: Apache/2.4.25 → Version disclosed (search for CVEs)</li><li>X-Powered-By: PHP/7.0.33 → Old PHP version (likely vulnerable)</li><li>Cookie missing HttpOnly flag → XSS can steal session</li><li>Cookie missing Secure flag → Can be sent over HTTP</li><li>Cookie missing SameSite attribute → CSRF vulnerable</li><li>No Content-Security-Policy → XSS protection missing</li><li>No X-Frame-Options → Clickjacking possible</li><li>No Strict-Transport-Security → HTTPS not enforced</li></ol><p><strong>Compare with httpbin:</strong></p><pre>curl -I https://httpbin.org</pre><p>Output:</p><pre>server: gunicorn/19.9.0<br>access-control-allow-origin: *<br>access-control-allow-credentials: true</pre><p>Still shows server information, but no detailed version number leaking CVE information.</p><p><strong>Security Header Checklist:</strong></p><p>When auditing, look for:</p><ul><li>Server/X-Powered-By headers → Information disclosure</li><li>Set-Cookie flags → Session security</li><li>CSP/X-Frame-Options/HSTS → Missing protections</li></ul><h4>Section 3: Response Timing Patterns</h4><p>Timing reveals backend behavior and can expose vulnerabilities even when no error messages appear.</p><p><strong>Basic Timing Measurement:</strong></p><p>Create a timing template:</p><pre>cat &gt; curl-timing.txt &lt;&lt; EOF<br>time_total: %{time_total}s\n<br>EOF</pre><p>Test an endpoint with artificial delay:</p><pre>curl -w &quot;@curl-timing.txt&quot; -o /dev/null -s https://httpbin.org/delay/2</pre><p>Output:</p><pre>time_total: 2.1s</pre><p><strong>Interpreting Timing Results:</strong></p><p><strong>Fast Response (&lt; 100ms):</strong></p><ul><li>Input rejected early in processing</li><li>Validation before backend logic</li><li>Generally good security design</li></ul><p><strong>Slow Response (&gt; 2s):</strong></p><ul><li>Backend processing occurred</li><li>Database query executed</li><li>Potential for timing-based attacks</li></ul><p><strong>Testing DVWA for Blind SQL Injection:</strong></p><pre># Normal request<br>time curl -b cookies.txt \<br>  &quot;http://localhost:8081/vulnerabilities/sqli/?id=1&amp;Submit=Submit&quot;</pre><pre># With SLEEP injection<br>time curl -b cookies.txt \<br>  &quot;http://localhost:8081/vulnerabilities/sqli_blind/?id=1&#39; AND SLEEP(5)--&amp;Submit=Submit&quot;</pre><p>If the second request takes 5+ seconds longer, blind SQL injection is confirmed.</p><p><strong>Key Pattern:</strong> If you can control response time, you can extract data blindly. This will be covered extensively in Part 2.</p><h4>Section 4: Error Message Analysis</h4><p>Error messages leak implementation details that can accelerate exploitation.</p><p><strong>Testing SQL Errors in DVWA:</strong></p><pre>curl -b cookies.txt \<br>  &quot;http://localhost:8081/vulnerabilities/sqli/?id=1&#39;&amp;Submit=Submit&quot;</pre><p>Response body reveals:</p><pre>You have an error in your SQL syntax; check the manual that <br>corresponds to your MySQL server version for the right syntax <br>to use near &#39;&#39;1&#39;&#39;&#39; at line 1</pre><p><strong>Information Extracted:</strong></p><ul><li>Database type: MySQL</li><li>Query structure leaked</li><li>Input reaches SQL query directly</li><li>SQL injection vulnerability confirmed</li></ul><p><strong>Testing File Inclusion Errors:</strong></p><pre>curl -b cookies.txt \<br>  &quot;http://localhost:8081/vulnerabilities/fi/?page=/etc/passwd&quot;</pre><p>Potential response:</p><pre>Warning: include(/etc/passwd): failed to open stream</pre><p><strong>Information Extracted:</strong></p><ul><li>Absolute paths in error messages</li><li>File system structure revealed</li><li>File inclusion vulnerability confirmed</li></ul><p><strong>Systematic Error Hunting:</strong></p><pre>curl http://target.com/test | grep -i &quot;error\|warning\|exception\|fatal\|mysql\|postgresql\|syntax&quot;</pre><p>Verbose errors are intelligence goldmines. Production systems should hide error details, but many don’t.</p><h3>Conclusion: What We’ve Covered</h3><p>You now have foundational skills in:</p><ul><li>Reading verbose output to troubleshoot connections at each layer</li><li>Interpreting status codes for security implications</li><li>Auditing headers for missing protection mechanisms</li><li>Recognizing error messages that leak information</li><li>Understanding session state management</li></ul><p>You can now observe and analyze server behavior systematically with cURL. Part 2 will teach you to actively exploit what you observe here. But that’s a topic for another day!</p><p>If you liked this Article I’d highly recommend you check out my <a href="https://github.com/bmp-43/Cybersecurity-Guideline">Github Repository</a> where I document my journey in this field alongside with my medium blogs. Also consider following me, who knows maybe my next article is even better?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=570a43fee895" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/a-practical-curl-methodology-for-security-testing-part-1-observation-570a43fee895">A Practical cURL Methodology for Security Testing — Part 1: Observation</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cache Poisoning: The Silent Web Attack You Need to Know About]]></title>
            <link>https://osintteam.blog/cache-poisoning-the-silent-web-attack-you-need-to-know-about-09c024910bb4?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/09c024910bb4</guid>
            <category><![CDATA[red-team]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[cloud-security]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Sat, 10 Jan 2026 19:57:52 GMT</pubDate>
            <atom:updated>2026-01-10T19:57:52.726Z</atom:updated>
            <content:encoded><![CDATA[<h3>When Performance Features Become Security Nightmares</h3><p><em>A deep dive into one of the web’s most overlooked attack vectors</em></p><blockquote><strong><em>⚠️ Note:</em></strong><em> This article is adapted from a comprehensive technical write-up. For full technical details, proof-of-concepts, and code examples, check out the complete guide on my </em><a href="https://github.com/bmp-43/Cybersecurity-Guideline/blob/main/Module%201%3A%20Foundations/Theory/HTTP%20Headers/Offensive%20Theory%202.md"><em>GitHub Repository</em></a><em>.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-A8bDdSzMK5fe4TqihVS6g.jpeg" /></figure><p>Imagine visiting your favorite website, and instead of seeing the homepage you know, your browser executes malicious code that steals your credentials. The worst part? The website itself didn’t get hacked — their cache did.</p><p>Welcome to cache poisoning, the attack vector that turns performance optimizations into weapons.</p><h3>What Is Cache Poisoning?</h3><p>Cache poisoning exploits a fundamental tension in web architecture: the need for speed versus the need for security. Caches exist to make websites faster by storing and reusing responses. But what happens when an attacker tricks the cache into storing malicious content?</p><p>The answer: every user who requests that resource gets served the poisoned version. One malicious request can compromise thousands of users.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tgnmJ1Bb2xj_H7R8EyDYjg.png" /></figure><h3>The Anatomy of an Attack</h3><p>Cache poisoning attacks typically exploit the X-Forwarded-Host header—a header originally designed to help proxies communicate the original host. The problem? Many applications blindly trust this header and use it to build URLs.</p><p>Here’s what a basic attack flow looks like:</p><p><strong>Step 1: Discovery</strong> An attacker sends a normal request and examines how the site constructs URLs for scripts, stylesheets, and images.</p><p><strong>Step 2: Injection</strong> They send a malicious request with a modified X-Forwarded-Host header pointing to their own domain.</p><p><strong>Step 3: Verification</strong> If the site reflects this header into the HTML without validation, the attacker confirms the vulnerability.</p><p><strong>Step 4: Cache Poisoning</strong> Once confirmed cacheable, the attacker poisons the cache, and every subsequent user gets the malicious response.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PisGWCc8PDjMhuJIJIWwhA.png" /></figure><h3>Three Devastating Attack Scenarios</h3><h3>1. XSS at Scale: JavaScript Hijacking</h3><p>This is the nightmare scenario. An attacker poisons the cache so that legitimate resources (like main.js) are loaded from their server instead.</p><pre>Normal: &lt;script src=&quot;https://legitimate-site.com/js/main.js&quot;&gt;<br>Poisoned: &lt;script src=&quot;https://attacker-controlled.com/js/main.js&quot;&gt;</pre><p>What can they do with this?</p><ul><li>Steal session cookies</li><li>Log every keystroke (passwords, credit cards)</li><li>Redirect users to phishing sites</li><li>Mine cryptocurrency in victims’ browsers</li></ul><p>The scariest part? The malicious script runs with the full trust of the legitimate site. Content Security Policies (CSP) won’t help if the poisoned content comes from the trusted origin itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CGD7PjpYwouboMyN0rFvLg.jpeg" /></figure><h3>2. Cache-Poisoned Denial of Service (CPDoS)</h3><p>Not all attacks need JavaScript. Sometimes the goal is simply destruction.</p><p>By poisoning the cache with error responses (400, 403, 500), an attacker can make critical resources completely unavailable. One poisoned request can take down a homepage for hours, served to every user who tries to access it.</p><p>Attack vectors include:</p><ul><li>Oversized headers that trigger backend rejections</li><li>Invalid hosts that cause upstream errors</li><li>Malformed requests that break backend logic</li></ul><p>The damage compounds if the max-age is long—a single poisoned response can persist for 24 hours or more.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GViJ9PkRJC2Y6TtphKkrLQ.png" /></figure><h3>3. Invisible Redirects: Phishing with Extra Steps</h3><p>The most insidious variant leverages open redirects. An attacker poisons endpoints that perform redirects, causing users to be seamlessly bounced to attacker-controlled domains.</p><p>Example flow:</p><ol><li>User clicks “Login” on instagram.com</li><li>Poisoned cache redirects them to instagrarn.com (typosquatting)</li><li>User, trusting the flow originated from Instagram, enters credentials</li><li>Attacker harvests credentials or hijacks sessions via leaked tokens</li></ol><p>Because the redirect originates from the legitimate domain, it bypasses user suspicion and many security warnings.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bYsel-ifbN_gqPihpzzzAA.png" /></figure><h3>Why Traditional Defenses Fail</h3><p><strong>“But we have a WAF!”</strong> Web Application Firewalls often focus on request bodies and known attack patterns. Cache poisoning happens at the HTTP header level, in areas WAFs don’t always scrutinize.</p><p><strong>“We validate input!”</strong> Many developers sanitize query parameters and form data but forget that headers like X-Forwarded-Host are equally controllable by attackers.</p><p><strong>“Our CSP is strict!”</strong> If the poisoned content is served from your own domain or the inline script is injected into cached HTML, CSP sees it as legitimate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cd7HR2cJVh76V95pr_w6xw.png" /></figure><h3>Real-World Impact</h3><p>While specific incidents are rarely publicized (for obvious reasons), cache poisoning vulnerabilities have been found in:</p><ul><li>Major CDN providers</li><li>Popular web frameworks</li><li>Enterprise content management systems</li><li>E-commerce platforms handling millions of transactions</li></ul><p>The attack’s silent nature means it can persist undetected for extended periods. Victims don’t report anomalies because everything “looks normal” — the malicious content is served from the legitimate site.</p><h3>The Defense Strategy</h3><p><strong>For Security Teams:</strong></p><p><strong>Header Hygiene</strong></p><ul><li>Never trust X-Forwarded-Host or similar headers by default</li><li>Validate against strict allowlists</li><li>Strip untrusted headers at the edge</li></ul><p><strong>Cache Architecture</strong></p><ul><li>Align cache keys with application logic</li><li>If a header affects the response, it MUST be in the Vary header</li><li>Use Cache-Control: private for dynamic content</li></ul><p><strong>Output Encoding</strong></p><ul><li>Context-aware escaping for every reflection point</li><li>Never concatenate user input into HTML attributes or tags</li></ul><p><strong>Monitoring</strong></p><ul><li>Alert on unexpected external domains in cached responses</li><li>Log cache anomalies and header mismatches</li><li>Regular penetration testing focused on cache behavior</li></ul><p><strong>For Developers:</strong></p><p>The golden rule: <strong>If it came from the request, don’t put it in the response — especially not in URLs.</strong></p><p>Use server-configured canonical domains. Build URLs from configuration files, not runtime input. Treat headers as toxic until proven otherwise.</p><h3>Testing Your Own Systems</h3><p>Want to know if you’re vulnerable? Here’s the basic test flow:</p><ol><li>Send a normal request, note all dynamically-built URLs</li><li>Send the same request with X-Forwarded-Host: test-domain.com</li><li>Check if your test domain appears in the response</li><li>If yes, verify cacheability with repeated requests</li><li>If it caches, you’re vulnerable</li></ol><p>👉 <strong>Full Technical Guide on Cache Poisoning with commands and analytics as well as other topics are on GitHub </strong><a href="https://github.com/bmp-43/Cybersecurity-Guideline/tree/main"><strong>Cybersecurity-Guideline</strong></a><strong> Repository</strong></p><h3>The Bigger Picture</h3><p>Cache poisoning represents a fundamental challenge in modern web architecture: the features that make applications fast (caching, CDNs, proxies) also create attack surfaces.</p><p>As web applications grow more complex and distributed, these vulnerabilities become harder to spot and easier to exploit. The attack requires no breach, no stolen credentials, no malware — just understanding how caches work and where trust assumptions fail.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gQ-QU_oYycmOIZMz-p9f-Q.png" /></figure><h3>Conclusion</h3><p>Cache poisoning isn’t just a theoretical attack or a bug bounty curiosity. It’s a practical exploitation technique that turns infrastructure against itself. One request, one cached response, thousands of victims.</p><p>The good news? It’s entirely preventable with proper header validation, cache configuration, and security awareness. The bad news? Most applications haven’t implemented these defenses.</p><p>If you’re a developer, security professional, or system administrator, treat cache poisoning like any other high-severity vulnerability class. Test for it. Defend against it. Don’t assume your stack handles it by default.</p><p><strong>Want to dive deeper?</strong> The full technical write-up includes:</p><ul><li>Complete attack scenarios with code</li><li>Bypass techniques for common defenses</li><li>Advanced payload crafting</li><li>Detailed mitigation strategies</li><li>Testing methodologies</li></ul><p><em>Have you encountered cache poisoning in the wild? What security measures has your organization implemented? Drop your thoughts in the comments.</em></p><p><em>For more cybersecurity research and offensive security techniques, follow me and check out my GitHub.</em></p><p><strong>Disclaimer:</strong> The techniques described are for educational and defensive security purposes only. Unauthorized testing against systems you don’t own or have explicit permission to test is illegal.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=09c024910bb4" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/cache-poisoning-the-silent-web-attack-you-need-to-know-about-09c024910bb4">Cache Poisoning: The Silent Web Attack You Need to Know About</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Weaponizing HTTP Headers: The Reconnaissance Phase]]></title>
            <link>https://osintteam.blog/weaponizing-http-headers-the-reconnaissance-phase-7bfaac86774b?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/7bfaac86774b</guid>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[osint]]></category>
            <category><![CDATA[information-security]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Tue, 06 Jan 2026 01:51:19 GMT</pubDate>
            <atom:updated>2026-03-02T17:26:33.356Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong><em>This is Part 1 of a series on offensive HTTP header exploitation.</em></strong><em> For the complete technical breakdown with detailed examples and methodologies, check out the </em><a href="https://github.com/aegismartin/Cybersecurity-Guideline/blob/main/Web-Vulnerabilities/HTTP-Headers/HTTP-Security-Headers.md"><em>full documentation on GitHub</em></a><em>.</em></blockquote><p>HTTP headers are the invisible infrastructure of every web request. Most security researchers treat them as boring metadata — a mistake that opens the door to serious vulnerabilities. Headers reveal tech stacks, expose internal logic, and when custom-built by developers, often lack the security rigor of standardized implementations.</p><p>This article covers how to identify security-relevant headers, what they reveal about your target, and why custom headers are a goldmine for penetration testing. Article will use AI images illustrations of actual security tools. The images are solely for the visualization of the example and do not serve purpose of misleading the audience.</p><h3>Why Custom Headers Matter</h3><p>Custom headers are application-specific — built by the dev team for their exact needs. Unlike RFC-standardized headers with strict specifications, custom headers are the wild west: no enforced rules, inconsistent validation, and often tied directly to critical backend logic.</p><p><strong>What makes them dangerous?</strong></p><ul><li><strong>Tech stack fingerprinting</strong>: Reveals frameworks, proxies, authentication layers</li><li><strong>Authorization logic leaks</strong>: Headers tied to user roles, permissions, internal trust paths</li><li><strong>Session handling clues</strong>: Custom session IDs, user mapping mechanisms</li><li><strong>Environment exposure</strong>: Staging/dev hostnames that are softer targets</li><li><strong>Attack chain fuel</strong>: Combine with IDOR, CORS misconfig, cache poisoning, auth bypass</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CsLIVs9pFFlcjfKEvnLEhg.png" /></figure><p>The key insight: <strong>A header becomes security-relevant when backend logic changes behavior based on its presence or value.</strong> Custom headers aren’t vulnerabilities themselves — they’re the blood trail leading to the actual security hole.</p><h3>How to Spot Custom Headers</h3><p>Headers starting with X- are obvious, but modern applications often skip that convention. Here&#39;s how to identify them:</p><h3>Detection Methodology</h3><ol><li><strong>Know your baseline</strong>: Memorize common standardized headers (Host, User-Agent, Accept, Cache-Control, etc.)</li><li><strong>Compare responses</strong>: Normal 200 vs error responses (400/403/500). Custom headers often appear when the server is “uncomfortable”</li><li><strong>Trigger parser errors</strong>: Malformed paths, bad encoding, unusual HTTP methods force sloppy error responses</li><li><strong>Pattern recognition</strong>: Names containing internal, debug, env, user, role, session are almost always custom</li><li><strong>Cross-site verification</strong>: If a header only exists on your target, it’s application-specific</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2vZCzanOkl0JHy5hy4jOpw.png" /></figure><h3>The Google Dorking Advantage</h3><p>Once you’ve identified a suspicious header, search for it: &quot;X-Custom-Header&quot; site:github.com</p><p>You’ll often find:</p><ul><li>Backend code interacting with that header</li><li>Configuration files with hardcoded values</li><li>Middleware checking for its presence</li><li>Issue discussions revealing its purpose</li></ul><h3>Real-World Examples</h3><h3>Example 1: Simple API Analysis</h3><p>Target: <a href="https://ipapi.co/json">https://ipapi.co/json</a></p><pre>curl -I https://ipapi.co/json</pre><p>Response includes standard Cloudflare headers (cf-ray, cf-cache-status) plus infrastructure indicators. While cf-ray is technically custom (Cloudflare-specific), it&#39;s not application-defined—it&#39;s infrastructure metadata used across thousands of sites.</p><p><strong>Takeaway</strong>: Not every non-RFC header is worth your time. Focus on truly application-specific ones.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dzb432ZfbRwn5PlnFiLOtA.png" /></figure><h3>Example 2: OpenAI API Deep Dive</h3><p>Target: <a href="https://api.openai.com/v1/models">https://api.openai.com/v1/models</a></p><pre>curl -I -H &quot;Authorization: Bearer fake-key&quot; https://api.openai.com/v1/models</pre><p>Custom headers discovered:</p><ul><li>openai-version: 2020-10-01 → API version targeting</li><li>x-request-id: [UUID] → Request tracking/logging</li><li>openai-processing-ms: 4 → Server-side timing info</li><li>x-envoy-upstream-service-time: 6 → Proxy timing</li><li>x-openai-proxy-wasm: v0.1 → Infrastructure version</li></ul><p><strong>What this reveals:</strong></p><p>Searching &quot;openai-version&quot; site:github.com confirms this is the API version identifier. Now you know exactly what version to hunt CVEs for.</p><p>Searching &quot;x-request-id&quot; site:github.com &quot;openai&quot; reveals it&#39;s used for error logging and debugging. The SDK documentation even shows: <em>&quot;All object responses provide a </em><em>_request_id property added from the </em><em>x-request-id response header for logging failing requests.&quot;</em></p><p><strong>Attack surface identified:</strong> Request correlation for timing attacks, version-specific exploits, internal service architecture mapping.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I1P3TimwYEeqkky5v_myhw.png" /></figure><h3>The Vary Header: Cache Behavior Indicator</h3><p>The Vary header tells caches which request headers affect response generation. It&#39;s not a security control—it&#39;s cache instruction.</p><pre>Vary: X-Forwarded-Host, Origin</pre><p>This means: <strong>The application is reading these headers and using them to generate responses.</strong></p><h3>What Vary Tells Red Teamers</h3><p>If a header appears in Vary, the backend is definitely using it. That&#39;s your signal to test if the application trusts user-controlled values in those headers.</p><p><strong>Example Test:</strong></p><pre>curl -i https://example.com/ -H &quot;X-Forwarded-Host: attacker.com&quot;</pre><p>If the response HTML reflects attacker.com in script sources or links, you&#39;ve confirmed the app trusts unvalidated input—opening the door to cache poisoning, SSRF, and more.</p><h3>Critical Insight</h3><p>Vary does NOT:</p><ul><li>Validate headers</li><li>Block malicious input</li><li>Make anything secure</li></ul><p>It only tells the cache: “These headers matter for response uniqueness.”</p><h3>Red Team Reconnaissance Strategy</h3><p><strong>Phase 1: Baseline Collection</strong></p><ul><li>Capture normal requests (200 OK responses)</li><li>Note all present headers</li><li>Identify non-standard names</li></ul><p><strong>Phase 2: Error Provocation</strong></p><ul><li>Send malformed requests (bad paths, methods, encoding)</li><li>Trigger 400/403/500 responses</li><li>Compare headers — new ones indicate custom error handling</li></ul><p><strong>Phase 3: OSINT Correlation</strong></p><ul><li>Google dork each suspicious header</li><li>Search GitHub for code references</li><li>Look for issue trackers, configs, documentation</li></ul><p><strong>Phase 4: Behavior Mapping</strong></p><ul><li>Test header manipulation (injection, removal, modification)</li><li>Observe response changes</li><li>Map which headers affect backend logic</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/1*BnY387QtQrdp7UMTwtig_Q.png" /></figure><h3>Key Takeaways</h3><ol><li><strong>Custom headers = uncharted territory.</strong> Less standardization means more room for implementation mistakes.</li><li><strong>Headers in </strong><strong>Vary are actively used by the backend.</strong> Prioritize testing these for trust issues.</li><li><strong>Non-200 responses leak more.</strong> Error states often expose custom headers hidden during normal operation.</li><li><strong>OSINT amplifies header recon.</strong> GitHub, issue trackers, and docs reveal how headers are actually used.</li><li><strong>Context matters.</strong> A timing header (processing-ms) isn&#39;t dangerous alone—but combined with other vectors, it enables timing attacks.</li></ol><h3>What’s Next</h3><p>This article covered <strong>identification and reconnaissance</strong>. Part 2 dives into <strong>exploitation</strong>: cache poisoning attacks (XSS, DoS, open redirects), bypassing CSP, and chaining header abuse with other vulnerabilities.</p><p>Understanding what headers reveal is step one. Learning how to weaponize that information is where real impact happens.</p><p><strong>Want the full technical breakdown?</strong> The complete methodology with detailed examples, additional test cases, and exploitation theory is available in the <a href="https://github.com/aegismartin/Cybersecurity-Guideline">Cybersecurity Guideline repository on GitHub.</a></p><p><strong>Follow for Part 2:</strong> Cache Poisoning Attacks via HTTP Headers — coming soon.</p><p><em>This content is for educational and authorized security testing only. Unauthorized access is illegal.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7bfaac86774b" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/weaponizing-http-headers-the-reconnaissance-phase-7bfaac86774b">Weaponizing HTTP Headers: The Reconnaissance Phase</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Your Web App is Probably Leaking Data (And How Headers Stop It)]]></title>
            <link>https://osintteam.blog/why-your-web-app-is-probably-leaking-data-and-how-headers-stop-it-7e0c47053162?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e0c47053162</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[cyber-security-awareness]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Fri, 02 Jan 2026 13:19:36 GMT</pubDate>
            <atom:updated>2026-01-10T19:57:30.670Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why Your Web App is Probably Leaking Data (And How Headers Stop It)</h3><p>Most developers think their web app is secure because they sanitize inputs and hash passwords. Meanwhile, their app is bleeding sensitive data through HTTP headers like a sieve — and they don’t even know it.</p><p>I’m not talking about exotic zero-days or nation-state attacks. I’m talking about misconfigurations so common that attackers check for them first. Session tokens leaking through referrer headers. Cross-site scripting bypassing basic input filters. Credentials intercepted because HTTPS wasn’t enforced properly.</p><p>The worst part? Most of these vulnerabilities could be fixed with a few lines of configuration. HTTP security headers are your first line of defense, yet they’re consistently overlooked, misconfigured, or ignored entirely.</p><p>Let me show you what’s probably wrong with your app right now — and how to fix it before someone exploits it.</p><h3>The Headers That Matter (And Why You Should Care)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*aTTfdohWPuAQ0s9dQqrOUw.png" /></figure><h3>1. Strict-Transport-Security: Stop Playing Russian Roulette with HTTP</h3><p>Here’s a fun scenario: your user connects to your site over HTTPS. Everything looks secure. Green padlock, encrypted traffic, the works. Then they click a link that redirects them to http://yoursite.com instead of <a href="https://yoursite.com./">https://yoursite.com.</a></p><p>Suddenly, every piece of data they send — session cookies, API tokens, personal information — is flying across the network in plain text. On public WiFi. Where anyone with Wireshark can grab it in seconds.</p><p>HSTS (HTTP Strict Transport Security) tells the browser: “Never connect to this site over HTTP. Ever. Not even if the user types it manually.”</p><pre>Strict-Transport-Security: max-age=31536000; includeSubDomains; preload</pre><p>This one header forces HTTPS for an entire year, applies it to all subdomains, and can even get your site preloaded into browsers so users are protected from their very first visit.</p><p><strong>The attack this stops:</strong> SSL stripping. An attacker on the network downgrades your HTTPS connection to HTTP and intercepts everything. HSTS makes this impossible after the first visit.</p><p><strong>Real consequence:</strong> Without HSTS, one malicious router between your user and your server means game over. With it, the browser refuses to downgrade, even if an attacker tries.</p><h3>2. Content-Security-Policy: The XSS Killer You’re Not Using</h3><p>Cross-Site Scripting (XSS) is still one of the most common vulnerabilities in web apps. Attackers inject malicious JavaScript into your pages, and suddenly they’re stealing user sessions, keylogging credentials, or redirecting users to phishing sites.</p><p>Most developers try to stop XSS by sanitizing inputs. That’s good, but it’s not enough. You need defense in depth. That’s where CSP comes in.</p><p>Content-Security-Policy tells the browser exactly where it’s allowed to load resources from. Scripts, stylesheets, images, iframes — everything. If an attacker manages to inject a script tag pointing to evil.com, the browser just... won&#39;t load it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*ucql8j7DG7gj9WNOd5ajcA.png" /></figure><pre>Content-Security-Policy: <br>    default-src &#39;self&#39;; <br>    script-src &#39;self&#39; https://trusted-cdn.com; <br>    object-src &#39;none&#39;;</pre><p>This policy says: “Only load resources from my own domain, scripts can come from my domain or this specific CDN, and block all plugins entirely.”</p><p><strong>The attack this stops:</strong> Reflected XSS, stored XSS, and even some DOM-based XSS. If the attacker’s payload tries to load from an unauthorized source, CSP blocks it cold.</p><p><strong>Why you’re not using it:</strong> Because it’s a pain to configure and will break your site if you get it wrong. Start with Content-Security-Policy-Report-Only to see what would be blocked without actually blocking it. Fix violations, then enforce.</p><p><strong>Pro tip:</strong> Avoid &#39;unsafe-inline&#39; and &#39;unsafe-eval&#39; like the plague. They basically disable CSP&#39;s protection. If you need inline scripts, use nonces or hashes instead.</p><h3>3. Cookie Flags: Your Session’s Only Hope</h3><p>Cookies are how web apps remember who you are. Mess up cookie security, and attackers can steal sessions without ever touching your password.</p><p>Let’s talk about three flags that should be on every session cookie you set:</p><p><strong>HttpOnly:</strong> Prevents JavaScript from reading the cookie. Without this, any XSS vulnerability instantly becomes a session hijacking vulnerability. The attacker just runs document.cookie and steals your session token.</p><p><strong>Secure:</strong> Cookie only travels over HTTPS. Without this, the session token can be intercepted on insecure connections. Public WiFi becomes an instant threat.</p><p><strong>SameSite:</strong> Controls whether the cookie is sent in cross-site requests. Without this, Cross-Site Request Forgery (CSRF) attacks become trivial. An attacker tricks your browser into making authenticated requests to your bank while you’re browsing their malicious site.</p><pre>Set-Cookie: sessionId=abc123; Secure; HttpOnly; SameSite=Strict</pre><p><strong>The attack this stops:</strong></p><ul><li>XSS + missing HttpOnly = instant session hijacking</li><li>HTTP + missing Secure = session interception over public WiFi</li><li>Missing SameSite = CSRF attacks that drain bank accounts</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SIBqo-PbpH5L5y0n8hE8xg.png" /></figure><h3>4. X-Frame-Options: Because Clickjacking is Still a Thing</h3><p>Clickjacking is an old attack, but it’s still effective because people keep forgetting to defend against it.</p><p>Here’s how it works: an attacker embeds your site in an invisible iframe on their malicious page. They position the iframe so that your “Delete Account” button is directly under their fake “Click here for free stuff!” button. User clicks, thinking they’re getting free stuff. They’re actually deleting their account.</p><p>X-Frame-Options prevents your site from being embedded in iframes on other domains:</p><pre>X-Frame-Options: DENY</pre><p>Or if you need to allow framing from your own domain:</p><pre>X-Frame-Options: SAMEORIGIN</pre><p><strong>The attack this stops:</strong> Clickjacking. User thinks they’re clicking one thing, actually performing sensitive actions on your site.</p><p><strong>Modern alternative:</strong> Use CSP’s frame-ancestors directive instead. It&#39;s more flexible and not deprecated:</p><pre>Content-Security-Policy: frame-ancestors &#39;self&#39;;</pre><h3>5. Referrer-Policy: Stop Leaking Sensitive URLs</h3><p>Your URLs probably contain more sensitive data than you think. Session tokens in query parameters. Internal paths revealing your architecture. User IDs that shouldn’t be public.</p><p>Every time a user clicks a link from your site to an external site, their browser sends a Referer header containing the full URL they came from. Including all those sensitive parameters.</p><p><strong>Real example:</strong></p><p>User logs into their bank: <a href="https://bank.com/account?session=ABC123">https://bank.com/account?session=ABC123</a></p><p>Page contains an image from an ad network: &lt;img src=&quot;https://ads.example.com/banner.png&quot;&gt;</p><p>Browser sends: Referer: <a href="https://bank.com/account?session=ABC123">https://bank.com/account?session=ABC123</a></p><p>Congratulations, you just leaked a session token to an advertising company.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7ZzlszChi-AMl5Da_3ahWQ.png" /></figure><p>Referrer-Policy controls what information gets sent:</p><pre>Referrer-Policy: strict-origin-when-cross-origin</pre><p>This sends the full URL to same-origin requests but only the origin (scheme + host + port) to cross-origin requests. No more leaking sensitive parameters.</p><p><strong>Better yet:</strong> Never put sensitive data in URLs in the first place. But Referrer-Policy is essential defense in depth.</p><h3>CORS: The Double-Edged Sword</h3><p>Same-Origin Policy (SOP) is the web’s fundamental security model. It says: “JavaScript on evil.com cannot read responses from bank.com.&quot; This is what prevents every site on the internet from stealing your data from every other site.</p><p>CORS (Cross-Origin Resource Sharing) creates controlled exceptions to SOP. It lets servers say “Actually, I trust trusted-partner.com to read my responses.&quot;</p><p>The problem? Misconfigured CORS is everywhere, and it’s devastating.</p><p><strong>The disaster scenario:</strong></p><pre>Access-Control-Allow-Origin: *<br>Access-Control-Allow-Credentials: true</pre><p>This configuration says “Any origin can read my responses, and yes, include credentials like cookies.”</p><p>Translation: Any website can steal your users’ data by making requests from their JavaScript.</p><p>An attacker hosts a site that makes requests to your API. Your users visit the attacker’s site. The attacker’s JavaScript makes authenticated requests to your API using the victim’s cookies. Your server responds. The attacker reads the response. Game over.</p><p><strong>How to do CORS right:</strong></p><pre>Access-Control-Allow-Origin: https://trusted-partner.com<br>Access-Control-Allow-Credentials: true</pre><p>Whitelist specific origins. Never use * with credentials. Validate origins server-side before echoing them back.</p><p><strong>The attack this stops:</strong> Unauthorized cross-origin API access, session hijacking, data theft through malicious websites.</p><h3>Cache-Control: Because Sensitive Data in Cache is a Time Bomb</h3><p>Browsers cache pages to speed up navigation. That’s great for performance. It’s terrible for security when those cached pages contain sensitive data.</p><p>Scenario: user logs into their banking app, checks their balance, logs out. Another user on the same computer hits the back button. Cached page loads. Previous user’s balance is still visible.</p><p>Or worse: the data is cached by a proxy server at a coffee shop. Every subsequent user gets served the previous person’s sensitive data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hVPSwXHqw_B5DX7M8b4K_A.png" /></figure><pre>Cache-Control: no-store, no-cache, must-revalidate<br>Pragma: no-cache<br>Expires: 0</pre><p>This combination tells browsers and proxies: “Never store this response. Always revalidate with the server. This content expires immediately.”</p><p><strong>When to use it:</strong> Any page containing PII, session tokens, financial data, or personal information. Better to be paranoid than compromised.</p><h3>The Testing Reality Check</h3><p>Here’s how you find out if your headers are protecting you:</p><p>Open DevTools → Network tab → Click any request → Look at Response Headers.</p><p>No Strict-Transport-Security? Your users are vulnerable to SSL stripping.</p><p>No Content-Security-Policy? XSS attacks bypass your input sanitization.</p><p>Session cookie without HttpOnly, Secure, and SameSite? Session hijacking is one XSS away.</p><p>Access-Control-Allow-Origin: * with credentials? Any site can steal your users&#39; data.</p><p><strong>The brutal truth:</strong> Most web apps fail these basic checks. Yours probably does too.</p><h3>Want to Go Deeper?</h3><p>This article covers the critical headers you need to know to stop actively leaking data. But there’s a lot more to HTTP security — advanced CSP configurations, nonce-based script loading, CORP and COEP for cross-origin isolation, comprehensive CORS testing methodologies, and real penetration testing workflows.</p><p>I’ve documented the full technical deep-dive, complete with testing procedures, curl commands, exploitation techniques, and defense strategies in my <a href="https://github.com/bmp-43/Cybersecurity-Guideline/blob/main/Module%201%3A%20Foundations/Theory/HTTP%20Headers/HTTP%20Security%20Headers.md">Cybersecurity Guideline repository on GitHub</a>.</p><p>If you’re serious about web security — whether you’re a developer hardening your app or a pentester looking for vulns — the GitHub guide has everything this article doesn’t. Server configuration examples for Nginx and Caddy, detailed VAPT testing workflows, exploitation scenarios, and every security header that matters.</p><p><strong>Check it out:</strong> <a href="https://github.com/bmp-43/Cybersecurity-Guideline/blob/main/Module%201%3A%20Foundations/Theory/HTTP%20Headers/HTTP%20Security%20Headers.md">HTTP Security Headers — Technical Guide</a></p><h3>The Bottom Line</h3><p>HTTP security headers aren’t optional security theater. They’re essential defense mechanisms that stop real attacks in production environments right now.</p><p>The headers we covered today:</p><ul><li><strong>HSTS</strong> stops SSL stripping and downgrade attacks</li><li><strong>CSP</strong> blocks XSS even when input sanitization fails</li><li><strong>Cookie flags</strong> prevent session hijacking, interception, and CSRF</li><li><strong>X-Frame-Options</strong> stops clickjacking</li><li><strong>Referrer-Policy</strong> prevents URL data leakage</li><li><strong>CORS</strong> controls who can read your API responses</li><li><strong>Cache-Control</strong> keeps sensitive data out of caches</li></ul><p>Most of these are single-line configurations. Most web apps don’t have them. That gap between “should” and “does” is where attackers live.</p><p>Check your headers. Fix what’s broken. Your users’ data depends on it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e0c47053162" width="1" height="1" alt=""><hr><p><a href="https://osintteam.blog/why-your-web-app-is-probably-leaking-data-and-how-headers-stop-it-7e0c47053162">Why Your Web App is Probably Leaking Data (And How Headers Stop It)</a> was originally published in <a href="https://osintteam.blog/">OSINT Team</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[New Year, Same Breaches: Why January Is the Hottest and Most Boring Month in Cybersecurity]]></title>
            <link>https://meetcyber.net/new-year-same-breaches-why-january-is-the-hottest-and-most-boring-month-in-cybersecurity-d9f32cba2e76?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9f32cba2e76</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[christmas]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Wed, 31 Dec 2025 10:33:00 GMT</pubDate>
            <atom:updated>2025-12-31T14:56:56.117Z</atom:updated>
            <content:encoded><![CDATA[<p>How many people do you know who genuinely enjoy working in late December and early January?</p><p>Motivation decays as the holidays approach. Teams slow down, attention slips, and excuses multiply. The only people who don’t seem affected are those who truly love their work — and attackers.</p><p>This isn’t surprising. During the Christmas holidays, everyone cuts corners. The missed alert could belong to a SOC analyst assuming it’s noise. The unresolved bug might belong to a developer deciding it can wait until after the hangover. Multiply this mindset across an organization, and you get the perfect environment for compromise.</p><p>What makes this period dangerous isn’t innovation. There are no flashy zero-days, no exotic exploits that set cybersecurity Twitter on fire. The attacks are boring. Phishing, misconfigurations, forgotten credentials. And that’s exactly why they work.</p><p>This article examines why cyberattacks spike during the Christmas–New Year period, the types of attacks most commonly observed, and the patterns behind them, using recent data and real-world examples.</p><h3>France’s national postal service (La Poste) hit by a cyberattack right <em>before Christmas</em></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*hoPHYLU9dW6pZ-ejDtQFig.png" /></figure><p>On <strong>December 22</strong>, France’s national postal service and its banking arm were hit by a <strong>distributed denial-of-service (DDoS) attack</strong>, disrupting parcel tracking and online banking during one of the busiest periods of the year. This wasn’t a minor incident — it occurred at <strong>peak holiday usage</strong>, slowing services millions rely on for last-minute deliveries. No financial data was stolen, suggesting the attack was likely <strong>hacktivism</strong>, with a pro-Russian group claiming responsibility.</p><p><a href="https://apnews.com/article/france-postal-service-cyberattack-4ea0c3e3bcb8a87341de8aebc1dfc916">More information on this attack can be found here</a></p><h3>Phishing Attack Compromises Cyberhaven’s Chrome Extension</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KkwIGEZs8ZeaM3amdMRTAQ.jpeg" /></figure><p>During the Christmas holiday in late December 2024, attackers managed to hijack the update process for a popular Chrome extension maintained by cybersecurity company Cyberhaven. By phishing a developer’s access to the Chrome Web Store, they published a malicious version of the extension that could steal session cookies and other sensitive data. The compromised version was distributed automatically between <strong>Dec 25 and Dec 26</strong>, exposing users who had auto‑update enabled before it was detected and removed within about a day. This incident illustrates how attackers leverage holiday downtime to compromise trusted software and slip malicious code into legitimate ecosystems.</p><p><a href="https://socradar.io/blog/phishing-attack-cyberhaven-chrome-extension/">More information on this attack can be found here</a></p><h3>Patterns and Trends Around the Holiday Season</h3><p>Ransomware &amp; holiday timing<br> Security reporting consistently shows that <strong>ransomware attacks spike on holidays and weekends</strong>, including Christmas/New Year periods, because attackers know defenders are stretched thin and slower to react. In one report, <strong>52% of ransomware attacks over the past year occurred on weekends or holidays</strong>. <a href="https://www.axios.com/2025/12/25/holidays-hackers-corporate-security-teams"><strong>Source</strong></a></p><p><strong>Alerts and attacks outside normal hours</strong><br> Studies from security teams show that significant portions of cyberattacks hit <strong>outside business hours</strong> — including holidays — with ransomware groups deliberately timing strikes when staffing dips. Research found things like <strong>76% of ransomware attacks happening outside normal hours</strong> and many security teams cutting staffing by up to 50% during holidays. <a href="https://www.itpro.com/security/cyber-professionals-are-losing-sleep-over-late-night-attacks"><strong>Source</strong></a></p><h3>Christmas specific attack tendencies</h3><p>These a<strong>re seasonal attack categories that spike around Christmas / New Year.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r9BguN7KVkQpbmq2gWFvIQ.png" /></figure><p><strong>Holiday-themed phishing &amp; scam campaigns</strong><br>Phishing attacks with fake delivery notices, bogus gift card offers, charity scams, or holiday deal hooks always surge during the Christmas period because people are <em>expecting</em> this kind of communication. <a href="https://www.prepaway.net/certification-training/rising-tide-cyber-threats-holiday-season"><strong>Source</strong></a></p><p><strong>Ransomware &amp; unattended systems</strong><br>Ransomware operators often strike when staff are out of office, encrypting systems and only being discovered <strong>after the holidays</strong> when workers return. <a href="https://www.cyberneticgi.com/christmas-season-cybersecurity-threats-organisations-must-watch"><strong>Source</strong></a></p><p><strong>Misconfigurations become weaponized</strong><br>Systems misconfigured earlier in the year often get exploited in December when defenders are slower to notice, especially with reduced monitoring during the holiday freeze. <a href="https://insights.integrity360.com/dont-get-sleighed-this-christmas-why-cyber-attacks-spike-during-the-holidays"><strong>Source</strong></a></p><h3>Bottom Line</h3><p>Hackers know that staffing dips, alert fatigue, and auto-updates create <strong>perfect conditions</strong>. Phishing, ransomware, and supply-chain attacks spike because <strong>defenders are slower, and users are distracted</strong>. This is the boring part that makes it terrifying — there’s nothing flashy, just methodical exploitation of human and organizational weaknesses.</p><p>For security teams, the lesson is simple: <strong>holiday downtime isn’t downtime for attackers</strong>. Awareness, patching, and monitoring can’t stop for a party. For everyone else, it’s a reminder that even a click during holiday shopping or browsing could be the start of a breach.</p><p>I hope all of you will have joyful and <strong>safe</strong> holidays. Best regards, and see you soon next year!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9f32cba2e76" width="1" height="1" alt=""><hr><p><a href="https://meetcyber.net/new-year-same-breaches-why-january-is-the-hottest-and-most-boring-month-in-cybersecurity-d9f32cba2e76">New Year, Same Breaches: Why January Is the Hottest and Most Boring Month in Cybersecurity</a> was originally published in <a href="https://meetcyber.net/">MeetCyber</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[HTTP Request Journey uncovered, a simple click is more complicated than we thought?]]></title>
            <link>https://meetcyber.net/the-http-request-response-lifecycle-b9c8cb7c4b61?source=rss-9ad96374ef56------2</link>
            <guid isPermaLink="false">https://medium.com/p/b9c8cb7c4b61</guid>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[internet-protocol]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Martin Simonyan]]></dc:creator>
            <pubDate>Tue, 30 Dec 2025 23:06:29 GMT</pubDate>
            <atom:updated>2025-12-31T08:06:11.019Z</atom:updated>
            <content:encoded><![CDATA[<h3>What Really Happens When You Load a Website</h3><p>When you type a URL into your browser and press Enter, the page appears almost instantly. It feels simple. One request, one response, done.</p><p>That illusion is a lie.</p><p>Behind those few milliseconds, your request passes through multiple systems, protocols, security layers, and networks before it ever reaches the application. Each step exists for a reason, and each one introduces performance considerations and potential attack surfaces.</p><p>This article walks through the <strong>high-level lifecycle of an HTTP request</strong>, focusing on how data actually travels across the internet and where security matters most.</p><blockquote><em>This is not beginner material. Basic familiarity with web concepts and networking is recommended.</em></blockquote><p>This article will intentionally focus on the high-level lifecycle and security implications.</p><p>A <strong>complete technical breakdown</strong>, including protocol-level details, handshakes, kernel processing, and network internals, is available on my GitHub:</p><p>👉 <a href="https://github.com/bmp-43/Cybersecurity-Guideline/blob/main/Module%201%3A%20Foundations/Theory/Request-Response%20Lifecycle.md">Click here</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*lox6m5hLn25CixpFv3A0pQ.png" /></figure><h3>1. The Client Builds the Request</h3><p>Everything starts on the client side.</p><p>Your browser or application constructs an HTTP or HTTPS request that includes:</p><ul><li>The target URL</li><li>The HTTP method like GET or POST</li><li>Headers such as Host, User-Agent, Accept, and Cookie</li><li>An optional body when data is being sent</li></ul><p>If the request is HTTPS, preparation for encryption begins immediately. At this point, nothing has left your machine yet. The request only exists as structured data waiting to be sent.</p><h3>2. Finding the Server with DNS</h3><p>Before a connection can happen, the client needs an IP address.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kzyv0zIRdHFhmLQS4z8uIA.png" /></figure><p>The domain name you typed is sent to a <strong>DNS resolver</strong>, which attempts to translate it into an IP address. This process is heavily cached to improve performance. If the IP is not already known, the request is resolved through the global DNS hierarchy until the authoritative server responds.</p><p>From a security perspective, DNS is critical. Misconfigurations, poisoning, or malicious resolvers can silently redirect traffic to attacker-controlled infrastructure. For example In March 2021, attackers hijacked DNS records for major DeFi platforms such as PancakeSwap and C.R.E.A.M. Finance, redirecting users to malicious clones of the real sites. Unsuspecting visitors entered wallet credentials or approved transactions, leading to significant loss of funds and highlighting just how devastating DNS attacks can be in the cryptocurrency space. This misconfiguration costed the victims around 150k US Dollars.</p><p>Once the IP address is resolved, the client finally knows where to send the request.</p><h3>3. Establishing a Connection and Trust</h3><p>With the destination IP known, the client establishes a connection.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tsMmW2P9UM6UnD34mmMm0g.png" /></figure><p>First comes the <strong>TCP handshake</strong>, which creates a reliable communication channel. If the connection is HTTPS, this is immediately followed by a <strong>TLS handshake</strong>, where encryption parameters are negotiated and the server proves its identity using certificates.</p><p>After this step:</p><ul><li>The connection is reliable</li><li>The communication is encrypted</li><li>The client trusts it is talking to the correct server</li></ul><p>Any weakness here breaks confidentiality and integrity entirely.</p><h3>4. Leaving the Local Network</h3><p>The request now exits your local network and enters your ISP’s infrastructure.</p><p>From here on, packets are routed across multiple networks using global routing protocols. Decisions are made dynamically based on performance, availability, and policy. Latency, packet loss, and routing inefficiencies start to matter.</p><p>This is where “the internet” actually begins.</p><h3>5. Traversing the Internet Core</h3><p>As packets move across backbone networks, they pass through:</p><ul><li>Routers that forward traffic hop by hop</li><li>Firewalls that inspect and filter connections</li><li>Monitoring and security systems designed to block abuse</li></ul><p>A single request may pass through dozens of hops before reaching its destination. Tools like traceroute reveal this path, often exposing where delays or failures occur.</p><p>From an attacker’s perspective, this phase is noisy but difficult to control. From a defender’s perspective, it is where large-scale filtering and mitigation happens.</p><h3>6. Caching and CDNs</h3><p>Before the request ever reaches the origin server, it may be intercepted by a caching layer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*0uICkKCB5N0PtmUPVNu7qQ.png" /></figure><p>Content Delivery Networks store copies of static resources close to users. If the requested content is already cached, it can be served immediately without contacting the origin server at all.</p><p>This dramatically improves performance and also provides security benefits such as DDoS mitigation and early request filtering.</p><p>If the cache does not have the content, the request continues onward.</p><h3>7. Load Balancing and Server Selection</h3><p>At the destination network, a load balancer decides which backend server should handle the request.</p><p>This enables:</p><ul><li>Horizontal scaling</li><li>Fault tolerance</li><li>Zero-downtime deployments</li></ul><p>Load balancers may also terminate TLS connections and inspect HTTP data at the application layer before forwarding requests internally.</p><h3>8. The Server and Application Logic</h3><p>Once the request reaches the backend server, the operating system processes the network data and hands it to the application.</p><p>The application then:</p><ul><li>Parses headers, parameters, cookies, and body data</li><li>Runs authentication and authorization logic</li><li>Applies validation and rate limiting</li><li>Executes business logic</li><li>Queries databases or caches</li><li>Constructs a response</li></ul><p>This is where most real-world vulnerabilities live. Logic flaws, injection issues, access control failures, and insecure integrations all happen here.</p><h3>9. The Response Travels Back</h3><p>The response follows the same path in reverse:</p><ul><li>Through the server stack</li><li>Back through load balancers and caches</li><li>Across the internet</li><li>Through your ISP</li><li>Back to your browser</li></ul><p>If HTTPS is used, the browser decrypts the response, processes headers, renders content, and triggers additional requests for images, scripts, and stylesheets.</p><p>The lifecycle completes, and the illusion of simplicity is restored.</p><h3>Final Thoughts</h3><p>A single HTTP request touches many layers:</p><ul><li>Networking</li><li>Cryptography</li><li>Routing</li><li>Caching</li><li>Application logic</li></ul><p>Each layer exists to improve performance, reliability, or security. Each layer can also be abused if misunderstood or misconfigured.</p><p>Understanding this lifecycle is foundational for anyone working in web development, infrastructure, or security.</p><h3>Full Technical Breakdown</h3><p>Reminder that this is a simplified version of the article. I’m documenting my entire red team learning journey on <a href="https://github.com/bmp-43/Cybersecurity-Guideline/blob/main/Module%201%3A%20Foundations/Theory/Request-Response%20Lifecycle.md">GitHub</a> — 10 modules covering everything from HTTP fundamentals to full kill chain exploitation.</p><p>Follow me so you don’t miss it. ⭐ Star the repo if this was useful</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9c8cb7c4b61" width="1" height="1" alt=""><hr><p><a href="https://meetcyber.net/the-http-request-response-lifecycle-b9c8cb7c4b61">HTTP Request Journey uncovered, a simple click is more complicated than we thought?</a> was originally published in <a href="https://meetcyber.net/">MeetCyber</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>