Okay.
Let's have a look at the trade options.
So let's have the first view inside this tool.
So I go into the apps directory space pane and we open this class text through Cha Cha with Shady Guy.
And this one over here, here we go.
This is the overview about this tool and it's super clean and I really like this tool.
On the left we've got those package names and those package names contain each of our classes underneath.
For example, within systems, we've got this alien behavior system and we can see the Java code out
of here if we get this one.
Chad We struggled with the compiling of this method and therefore it puts out those bytecode reference.
So we do not get the Java source code out of this one right now.
Okay.
A good starting point is this one over here because this package name is identical to the package identifier
of this application.
And this is very likely the case that the code underneath here has been added by the developer because
we also results, for example, the Android Java classes that comes bundled with the Android system
and that are not interesting to us.
Therefore this one seems to be from the developer.
And yeah, we also have proof this already.
So underneath this package name there might be a lot of interesting stuff where I would start reverse
engineering this application.
JDK comes with a lot of nice options and let's discuss them real quick.
We've got this one, for example, this is open type and we can search here for types.
For example, if you type in player, then we get those, see, which means classes or this E, which
means enum types.
There's also an AI for interfaces.
And we can see here, for example, if I get more now we've got all classes that contains player at
this point, if you want to search within the whole code, for example, for variables or method names,
we have to use a different search, which is right next to this one.
And here we can see what we want to search for.
And yeah, normally I check everything right here because we are not really because we do not really
know what we are looking for.
For example, if you look for a as this might be a field name, it might be a method or an constructor
and so on.
Therefore, I like to move on with all of them.
If the output gets too large.
I try to, yeah.
Minimize this approach.
For example, if we search for, as we might not search for type or fields, we might search for as
within methods or constructors, for example.
But most of the time this is not the case.
So we can stick to all.
And it's also nice to have this X over here and it's also case insensitive.
For example, if we search for something, let's say, Aiden, we get now all this alien results over
there and here, for example, we can see, okay, here has been an alien class, but this one is a
groups class and this group's class seems to contain some string reference with Alien.
And here we go.
We've got string aliens, alien shots and so on.
So this search is the most used window in category for me right now.
Okay.
Next, we've got this one, which is the type hierarchy.
I'm also not sure about this pronunciation.
I hope it's correct.
And this comes super handy during our reverse engineering approach because it shows the inheritance
of those classes.
For example, we've got this alien behavior system over here and this one extends this entity processing
system if we go to the top.
We can see.
Yes, it extends the entity processing system and this one extends the entity system.
We can see this over here.
So there we can see the inheritance through all those classes, which is super handy during our reverse
engineering process.
All right.
And last but not least, what's left?
The only thing that's left are those preferences.
We can escape Unicode characters.
This one is pretty interesting.
Directory directory exploration.
Sorry for this one.
Maximum depth.
I've tested this with an application because I was not sure if Shady Guy is searching into files that
are in subdirectories up to 40.
So if you add 40 directories into one application, my assumption was we might miss them.
But I have tested it and it works.
But if you encounter an application that has a lot of subdirectories, it might be some obfuscation
or some anti reverse mechanisms.
So please check them out manually.
Otherwise, the rest is not that important.
And yeah, maybe the font size might come handy if you want to increase them to 40 for example, then
14.
Sorry, then it's easier to read and that's all about it.
Right now we load those Java classes into this file and we can nicely reverse engineer this application
right now by having all those tools.
In most cases, we simply stick to this one over here, which is the search engine.
In the next section, we take a look at ADX, which is a command line tool and Shade X, which is the
graphical user interface for this one.
And within this tool we can feed in a whole APK, which is super nice, but it also has some disadvantages,
which I would like to point out regarding to this approach.
All right.
That's all for now.
Feel free to browse around and reverse engineer this application after I have introduced our tool.
This will be definitely your task that you get familiar with this, and I also provide you some tasks
to do.
For example, to find a player lives and other stuff.
I do not want to spoil it that much right now.