Hi.
Welcome back everyone.
In this lecture we are going to develop better more access to so remote access to really give us access
to do more to victims.
And then we can use this success to do whatever else we want to do on the intended victim machine.
So every communication not transmission of that time between these two devices will be programmed and
go along.
We will develop two programs the first one for the victim and the second one for the hacker.
The feature of these the victim or malware is that the malware will try to connect automatically with
the hacker.
That is our machine.
We don't have to do anything you just have to run the victim machine once and then every time a hack
on wants to gain access to this victim the victim will always be trying to connect to the hacker said.
And then we will develop a feature in which we will have an ability to perform or execute commands on
the victim.
For example we will take commands from our hacker system and then these command will be sent to the
victim and then similarly these commands will be executed on the victim machine and we will get the
results back to the hacker system and then we will also try to develop the problem in such a way that
we can have a long term access to this system to this victim.
So we don't have to worry about.
Every time we want to connect to the victim or not and then we will also develop a feature in which
we uh upload and download files from the victim machine.
This can be very helpful in that that happened also for stealing passwords etc..
Okay.
So the first thing we will do in my life helping this program is that we will create two programs one
for the software or hacker and the other one third with no plane and then the first thing we want to
do is that we want to write a program that will try to establish connection between these two devices.
So our first step would be to create a package to handle these connections properly.
And once we have these connection we will be able to build on these connections and develop different
features that will explode later in our lectures.
So we have two machines.
The first one would be a windows down the victim machine so our victim will be a windows down machine
and then we will have a hack that which will be a colleague Linux machine.
So we have to do ACS at the moment and then we will try to stack this victim through this haircut or
call the machine.
We will write a set of editable realm for this hacker machine which will always be listening to the
and are incoming connections and then we will have a victim program that whenever we run it it will
try to connect with the set of a doctor medically the IP address for the hacker machine will be will
they do that 168 32 about 13 and then for the victim it would be 1 9 2 1 6 8 0 13.
So I will try to keep this constant throughout the creation of this malware so you don't get confused.
I have redefined these IP addresses so it's not a problem and you go through these lectures before going
into the detail.
Let's start with what our methodology will be.
So our first step would be to listen for incoming connections on server so our central program will
always be listening and then providing the server is listening.
We really create a victim program that whenever we run the program it really tried to communicate with
the server.
Once the victim communicate to the server.
There will be an establishment of a connection and then these two devices will acknowledge each that
connections for example the cell will tell that I've got a connection from the victim.
And similarly just for our understanding we will print out a statement on the victim machines that will
show that we have established connection with the central node that we want to be in victim number we
want to be as discreet as possible but here since our goal is learning so we won't be using much of
like uh privacy in this case.
And we will sprint out statements on the victim machines as well but you will see at the end that we
will try to make the victim pull them as invisible as possible so we don't get detected.
So there will be no screen output on the machine while we run the programs.
But during our learning phase we will print out different statements on the word waiting machines so
that we can have an idea of what is happening on the recording machine.
Okay.
Once there is acknowledgement of connection from both sides the next step is to start sending that out
communicating with with other device.
So firstly will you create a program that will end that add to the haircut and then you will receive
data from the haircut.
So we know that we have a proper working connection between these two devices.
And then once we have everything set up we will start building on top of this and start creating more
and more advanced features.
So this is showing the graphically here we have overcome P.C. here and then we have a haircut.
So a haircut is always listening and once the vector machine tries to connect with the hacker we are
establishing a connection between these two devices and then once the connection is established the
hacker sends an acknowledgement to the ATM machine.
Similarly the machine sends an acknowledgement to the hacker was this acknowledgement an initial connection
established where we tried to send data from hacker to the victim machine and then the Melinda can go
from victim to that as well.
So it's a bio dad X and then communication.
So that's it for this lecture See you next on.