What are the things that
would be very helpful in terms of analyzing in
for the applications, for vulnerabilities, has the ability to decompile the
application back into its source code Java languages
that are similar to Java that compiled into
a bike coat that is running against virtual machine.
It's possible for us to reverse the compilation
process to turn the bike could back into something
that resembles the original source code of the
matching won't always be perfect. You will do some information
typically from it. However, most of
the important pieces are going to still be there and since those
pieces will be, there will be able to not only understand what
the application is doing but actually be able to see the source code
and be able to pick out specific, vulnerable aspects that
we want to be able to work with Sol. In this video May
demonstrate how we can reverse reverse engineer
essentially what he compiled an application. So there's
a lot of different ways that people would typically used to do this
their chores, like apt to land.
Igd that will allow us to
decompile the application
and then reverse it back into Java code.
I actually used one called jednej a
DX and I cannot put links to
these inside of a resources section, but I'm inside
of here. There is essentially in the bin. There's
a gooey that we can launch watch this for
able to actually decompile any APK that
we may have on our computer. So I had to come into our
directory here and I'm going to go grab the application that
we installed and I run this through the decompiler.
And what you see here is that we'll get a set of source code
and the set of resources that are used inside of this
application.
When you're first looking at an application, is a lot
of different information that's valuable to us. The Manifest file
is one that's going to be extremely useful to tell
you a lot of different things. Such as the permissions that are used by
the application. They will tell you what activities exist, inside
the application. They will tell you about intense. It will
tell you about things, like content providers
and such if they exist and it will tell you what versions
We Target, it will give
you a whole plethora of high-level information that will allow you
to better understand the attack surface that you're working with. So
this is one file. That would be very useful for
us to be able to look at resources are
going to be a lot of like the the graphical interface is in
such that you going to be working with a lot of this really isn't
particularly useful. I don't think most of
the time. This is just a white guy. You don't search for
your information that comes from this process. The medit
in full, tell you different information through some certificate details
that are sometimes.
Helpful, I'm at was a manifest file, which
I could tell you a little bit of valuable information. Potentially give
you a bit of a layout of all the things
that exist inside of like the red folder and it
will allow you to get a bit of
an understanding behind like the contents sofa of the
Manifest. For instance, Library, Syracuse,
instead of the application fees are typically written
in C or C plus plus and compiled. These can't
be a decompiled what we can do
with these. We can analyze like strings that makes sense. I thought
we might be able to break it down into something that
might be able to tell us some information about the
shared Library are shared object. But I want to
time these are things that we won't be able to necessarily taken
too, too deeply. We will see you in a few examples. We
actually can go through these and gain some form of relevant
information.
And finally, we have her actual source code files which are
the actual source of the application itself. If you take
a look at these, you'll be able to see you like each of the different pieces that
goes into building the actual application itself. So you
can you pull up any of the code that actually exists and you'll
be able to see exactly what code is being used. You can
do this sort of thing with all. I would
say, basically any Android application, you should be able
to get service code unless it's like heavily encrypted or
obscured in some way. This will
typically be possible.
It's a few other things that are useful for this. We can
search this for specific keywords. So Fritz if we
find like an error message or something like that that we want
to look up. We can try looking it up. You can try
looking up, things like password. See you want to check out like what
you asked me to search, you can search classes. You can search methods Fields
a code for instance and you can see here.
We can serve like pick out pieces of information that might be of interest
to us. So here's an example here. Where
were in sitting at this equal, a user username and a
password. It seems so hot. This, for instance, would be some
information that might be able to gather from decompiling the application. So
this is your idea of how we can.
I see decompile Android applications. And from here. We
have all the tools that were going to need to how to be
able to analyze different applications to
be able to look at common Android vulnerabilities. So that's what
we will take a look at next.