What's going on, you guys ever need to here with Section 10 of my beginning to explore ethical hacking
course?
All right.
So in Section ten, we're going to be going over website and web application hacking.
So we went over how to infiltrate networks, how to hack into computers, but now how do we hack into
websites and web apps?
This is going to be a skill that you definitely need if you want to become a very reputable and respectable
professional ethical hacker.
Right.
As usual, just as a quick introduction, like I said in this section, we're going to be going over
exactly how you can hack into websites and web applications using a variety of tools and tactics.
So more specifically, we're going to talk about the other VSP top 10 webapp vulnerabilities.
Very important to know.
We're going to be talking about Web applications scaling to different tools that we use for those.
Well, let's talk about Esquibel injections, croci scripting.
We're going to talk about directory traversal vulnerabilities, content injection, which kind of goes
across the scripting and a few other Web application vulnerabilities.
And we're going to get some hands on practice with this, OK.
So just as a quick disclaimer, anything that you learn from this section is purely for educational
purposes and is meant to be used for ethical hacking only.
I do not advocate or approve of anyone utilizing these techniques to perform malicious actions against
any device or network unless given permission to do so prior.
OK, so now let's talk about the O.W. is the top 10 Web application vulnerabilities.
OK, so these are pretty much every few years or so the WSP, they go through and determine, you know,
what the top vulnerabilities to where applications are.
So this is the typical chart.
So as of like 2015, these are the top 10.
So you're going to see the most Web applications are vulnerable to one or more or all of these 10 items
are here.
So just to go down the list very quickly, injection is ranked as the number one, which is pretty much
what it sounds like.
It's when you inject malicious code into a website and as possible, a lot of the times, because certain
checks are performed when input is given to an application, and therefore it can allow you to inject,
you know, like malicious code.
Broken authentication just refers to the authentication method being broken for some reason, like maybe
someone can log in with a with a blank password or a blank username or there's something wrong with
the authentication sessions aren't configured correctly.
All kinds of different things that could be so broken.
Authentication is definitely a big thing that you'll see.
Number three will be the sensitive data exposure.
So a lot of the times developers may expose sensitive data like, you know, maybe from databases instead
of just from lack of security and kind of ties into these other ones.
Or they may also leak out sensitive data on accident, you know, via things like comments or just different
parts of the code.
So number four, it's called an XML external entities.
So when you attack on amount and it's easy, it's pretty much when an application that parses XML input
is attacked and the attack occurs when XML input contain a reference to an external entity is processed
by weakly configured XML parser.
So this allows attackers to actually be able to take advantage of that and, you know, exploit it and
take over potential, take over the server.
Broken access control is the next one and broken access control is pretty much what it sounds like is
when maybe like a regular user can escalate the privileges or have access to do things that they shouldn't
be able to do.
So it's kind of like broken authentication or something is just wrong.
And a security misconfiguration kind of ties into those other ones, just having things figured on the
server and application.
And it just allows users to do things that they should not be able to do.
The next one is going to be croci scripting.
This is part one of the most popular ones.
Crosseyed scripting is pretty much when you're sending malicious data into either into the URL and it
gets executed or into a page.
And every time the page loads, the malicious code may excuse us croci scripting and it's pretty much
when developers don't.
Chet, you know, they don't sanitize the input into the application, so it causes major issues and
causes, including one of the biggest vulnerabilities out there, insecure serialisation, is exactly
what it sounds like when decentralizing data is just done in a very insecure manner and allows attackers
just to take advantage of it.
The next one kind of speaks for itself using opponents and vulnerabilities.
So a lot of applications have like third party dependencies and these dependencies may have known vulnerabilities
and those are attack vectors for hackers.
So if a developer uses a component that has known vulnerabilities and a hacker finds out that Kapone
is being used, they could take advantage of that.
So that's something that developers need to keep in mind.
And then number 10, insufficient logging in monitoring.
And this is an issue because if you don't log or monitor what's going on with the application, you
never know what's happening.
You know, you could be getting attacked on an hourly, daily basis.
You never know if you're not logging, you know, access in terms or specific traffic that's coming
into the application or the server, then, you know, you're not going to know what's going on.
So that's definitely a major vulnerability.
And it doesn't allow you to actually figure out that there may be an issue or it won't allow you to
figure out what's going on.
And if you do discover an issue when an attack is going on.