Welcome back.
Let's see a different example of finding him an injection vulnerability for this, we're going to need
our over spurtle machine, so make sure that it is started.
Make sure that you have it started right here and that intercept is turned off.
Now, what we want to do is we want to navigate to the IP address of our virtual machine.
Then we want to navigate to always mattilda day to.
And you will notice that right here, if we go to August 2013 and a one injection, we will have multiple
examples of an injection or should I say multiple practice examples of it.
Let's go to, for example, this one.
Let's go to injection and then Browsr info.
If I click on that, it will open a page that it should be vulnerable to an injection.
Right.
But compared to the last example that we saw here, we don't really see any user input that we can use
to inject code.
We can't enter our HTML code anywhere on this page.
So what are we going to do?
Well, let's take a look at the page a little bit closer.
If we take a look at all of the information that we have right here, we're going to notice something
quite familiar for us, which is this user agent string.
It appears to be our user agent or us.
Now, if we remember in the beheaders, there is a user agent header that has this information for us.
So could it be that perhaps the user agent, Heather, is getting reflected on this page?
I mean, we can give it a try.
Let's see what happens once we reload this page while intercept is turned on.
So let's go to our Burset, turn on the intercept, and let's reload this page.
So straightaway we get this HTP request, and this is the same request for this page since we tried
to reload it.
Now, let's compare this information right here, which is the user agent drink with the user agent
string that we got in our HTP headers.
So here it is.
As we can see, it's pretty much the same thing.
So even though we don't have a user input field on our webpage, could we possibly try to inject HTML
code in the user agent field?
Well, let's give it a try.
If I delete the current user agent and I type H1 tags and then test and then I close H1 tags and let's
also, for the purposes of this tutorial, add the underlying tags just so we can see whether it will
also underline it.
So if we open the tags, we must also close them.
And once we inject this, hopefully if it gets reflected on this page, we're going to see test written
in header sites one and also underlined.
Let's give it a try.
Let's forward this packet and turn of the intercept.
Go back to the page and here it is.
We get test reflected as an HTML code.
How cool is that?
We didn't use any user input field on the page, but we still managed to inject HTML code through HTTP
headers.
Awesome.
This is just another example of an injection, and in the next video, we're going to take a look at
even more interesting example and more useful example of the injection.
See you in the next video.