Before we finish off with the access section and the access vulnerability, I want to just mention one
thing that we have within our own SPW, a application.
Now, we do have a lot of these training applications on this virtual machine, but if you scroll a
little bit down, you also have old vulnerable versions of real applications.
And once you finish through this course and you finish all of these vulnerabilities, you can go through
these real world applications that really existed previously and test for real vulnerabilities that
were previously found.
For example, since we are in the access section, let's try to find an access vulnerability on one
of these applications.
There are many, such as Joomla Aves starts to key.
We have WordPress, we have get and many others as well.
So let's, for example, go with this one.
Let's go with get the.
We have one search bar, we can go through all of these pages right here, but since we are in the access
section, this search bar might be interesting for us.
Let's type in test just to see what happens with our input so we get test written right here.
OK.
But what happens if we, for example, try to inject a simple script?
Let's go.
Hmm, it does get reflected here, but nothing really happens.
Let's take a look at the source code.
Let's once again try to find the alert, and here it is.
Besides, there we also have it right here.
So on to different places.
Let's go with this place first.
So we have open input tax and our script is being added between these double quotes right here inside
of our value parameter.
So what would happen if we were to, for example, type in something right here, for example, test?
Then we manually close the double quotes and then we add the ending HTML sine to end this entire input
part.
And after that, we inject our code.
Let's see if that would work.
Let's go back, delete this and we type in test, for example, then we type in closing double quotes,
then we close the HTML tax and now we run the script.
So let's do it like this simple open script and close script with the alert function in between.
This is our payload and now if we run it, well, here it is.
We get access vulnerability in this application.
Let's just quickly take a look at the code.
To see what happened with our input here is the input field, and what happened is value is now equal
test.
As we can see right here, the input, open parameters are getting closed sooner than in real application.
And then we are running the script alert function.
The first of the code, which belonged to the input function, is getting processed as a regular text.
That's why we have it outputted right here.
So how cool is that?
You can go through these real applications and you can try to search for all of the vulnerabilities
that we covered and see which vulnerabilities you managed to find.
Nonetheless, we have fully covered access right now.
And in the next lecture, we're going to start off with another big quotability, which is called SQL
injection.