Everybody and welcome to the first video in the mini series that we're going to be doing on medicinally
now.
What is medicinally Meadows point is a exploitation flame framework that's open source and it provides
a lot of usability when going through the pen testing process.
So it has a few unique features in it kind of is a one stop shop for a lot of things.
However some things again like I mentioned before need to be done manually.
However medicine does a really good job at kind of bringing everything together in a structured way.
So it's not kind of somebody writes it one way somebody writes it another everything is kind of structured
in the same way.
So you can generally get a good reliability standpoint from my display.
Now there's a few common uses for this Metis boy can do reconnaissance so it can do and map scans any
sort of recon that you want for the most part as long as it's available in the tool on top of that and
also has a reporting function which allows it to store the information inside of its own local DV which
allows you to work as a group and you can have multiple people pushed to the same db if you really wanted
to now display can also keep track of exploits that are currently published for the framework itself.
So there's I believe eighteen hundred or two thousand active validated and tested exploits that are
written in such a way that allows it to change the payload out for what you want to do which will go
over payloads and exploits in its own video but understand that it has its own list of pre-built exploits
built in Ruby on top of this they have something called him interpreter which will go over in its own
video because it's quite a wide topic however interpreter is its own special shell that allows you to
load in tools that you want without ever having to touch the disk which is very important to bypass
a these and multiple other things.
It also allows you to migrate processes and perform privilege escalation and even pivoting across the
network but Metis buoyed itself can also use sessions that it keeps track of.
So if you exploit a machine and you keep track and it will keep track of that session you can actually
tell your local machine and Metis point that it wants to send all traffic for this command or this exploit
over the session and it will actually pivot through and send all the traffic to the host to attack another.
So it does have a lot of usability but on Kelley if we go ahead and open up a terminal to access Metis
Boyd we're gonna do MSF console.
Now there's one more thing I want to mention about Metis boy is it's also very helpful for export development
because it gives a lot of nice tools around finding distances and memory on one thing where things should
be based on a unique pattern so it can be it's a very very very very useful tool.
And I encourage all of you to go out and look and learn more about this after this mini course because
this is not going to cover everything depending on what you want to do.
It's going to cover a lot of other things like the exploit development.
There's a lot of niche tools that it has built in that we're definitely not going to be using in this
particular course that will be saved for the exploitation course.
Now when we run MSF console we will it'll go ahead and start preloaded things everything in the memory
and normally it comes with some unique and interesting pixel art on the screen once it finishes loading.
While this is going on to talk about something else motorsport also has the ability to generate payloads
as you want and give you the raw shell code or the raw codes.
Now this is important when you want to work with custom exploits so you you are building your own or
maybe you're downloading one from the Internet and you want to change out the show code that they're
using because either you don't trust it you don't understand assembly enough to it to dissect that and
or maybe the assembly is just too complicated for whatever level you happen to be at.
Which is entirely ok you can use medicinally to build in your own because most of the time those those
show codes are written either manually or in most cases used with my display to generate.
And this is done with something called M.S. venom but we will go over that in just a little bit so here
we are we've got MSF console loaded up so you can see it's an internal interactive command line.
So we run help here we'll see that there's a lot of options so we can see here we've got a credentials
database so that allows us to list all the creds that it has found so you can rip hashes from a machine
or if you want to add credentials to this yourself you can.
It has a database function like I mentioned before we can do workspaces listing vulnerabilities any
notes and he looked that we happen to find we have some developer things but we're not going to go over
that.
We can do our CE scripts we've got jobs which so everything that's ran in that's boy is considered a
job.
So when you spawn off a reverse handler to catch your shell that you just sent or the exploit you sent
that's supposed to connect back that's those are two separate jobs.
So think of the jobs as separate processes but under the same parent of medics like MSF console.
Now we've got module commands which again there's there's a few types of modules here.
There's some recon based modules there are exploit modules and then there's payloads.
So and there's also privilege escalation exploits in there as well.
So because you can you can send the privilege escalation exploit across the interpreter shell and then
up to the host.
So you could actually exploit it live without having to leave a single command Jason so this holds a
lot of like reloading the module so when we go over how to add a particular module to this and the common
look of what it is you're going to reload it here.
So if we keep going up here we see we've got a list of core commands which are our standard command
line options.
We need our version and we can set specific variables view the threads mess around with the spool save
certain sessions trying to change all the routes history of our commands load certain frameworks so
there's is this is a very very very large tool and there's a lot going on here.
But what I'm going to walk you through is how to use that as point for actually attacking a machine
so you can get a better and a good idea of how it works.
But what I also want to note in here is you can run actual commands themselves that aren't necessary
medicine.
So if we do if config we can see here it goes ahead and accepts that already directly to the system.
So if we want to do and map scan as an example
Tony so it will go ahead and launch that scan and let us know what it found.
So it's important to always double check and see what options are available and a new tool metabolite
would be a new tool for you.
I always recommend going out and finding different tutorials always look at more than one because there's
gonna be something I mentioned here that might not be in another trial and then other tutorials were
mentioned stuff that I have not mentioned yet.
So for now what I want you to do is load up and console and go ahead and use help kind of play around
with some of the options are show a few of the lists.
So like show and search just kind of search for a few things using the help is always the quickest way
to figure things out but I want you to get familiar with some of the commands and some of the options
in here that you're able to use.
So go ahead and play around with that in the next video we'll be taking this a little step further.