All right, guys.
So once again, after all the theory.
Now let's have a practical view onto this topic and let's do some exercises and practices a little bit,
because otherwise it's really hard to grasp.
Right.
Therefore, let's have a look here back at Ubuntu VM and I have prepared a really nice application for
you.
As always, you can download the whole source code as an attachment of the section because we have taken
a look into reverse engineering yet and the application is fitting into our alarm system topic.
And even if we are missing, let's say, quite a few features, we've got an use case which I encountered
in a real world application.
So this is something I really want to show you in this yet, let's say mocking application.
All right, let's have a look.
So I've already got the smartphone running.
Let's enable it.
And if you scroll up, we've got this this amazing app alarm pin.
So this time I have put some effort into the layout and I hope it looks okay.
So never mind.
I mean, this colour scheme.
Yeah, let's go over this.
So we've gotten logging and we've gotten username and password.
So I will tell you what these, these features are.
The username is admin and the password.
It's a pin, it consists of numbers and I guess the initial password is one three, three, seven,
but.
If you click login?
Yes.
It's still working.
I thought I have played around a little bit too much with this one, but yes, here we have it.
So now after logging in, I mean, we have to verify if every pin can be accepted because I have written
this application, but let's say the user has some pin and we need to know this pin.
Then we get into the next activity which is now some kind of profile activity.
And here we can change the pin.
We can also see that we've got this admin field over here, this one.
So from the first activity there will be already data passed into this activity.
The username and this also happens once again if we clicking on change pin, if you click on Change
PIN, then we can see the username.
Admin will be also passed to this application and now we can change the pin for this admin for example.
One, two, three, four.
And if you click send.
PIN updated successfully then typo no oc perfect.
So now if we close this application, get rid of this line.
And if you're opening it once again, let's see if if my programming skills are really that nice.
Username admin password.
One, three, three, seven.
Log in.
PIN is incorrect.
Perfect.
So you can see this.
Even this even survives and restart of this application.
So we are having some, some file content over here.
Okay, let's enter this pin.
And here we have now the next activity.
Let's take a look into the source code because then we will see how those information will be passed
from one activity to the next one.
One question for this one.
Is it an implicit or explicit intent?
Absolutely correct, guys.
It's, of course, an explicit intent because we know which destination we want to call.
In this case, it's a profile activity.
And if you click change pin, it's the change pin activity.
So we know the destination.
We want to go.
All right.
So let's have look into the source code.
And as always, you can find the source code as an attachment of the section until we talk about reverse
engineering, then you you do not have the convenient source code anymore, because then we need to
do this by ourselves.
All right.
You can, of course, also start doing it right now with the excuse me or the the other tools that are
mentioned in the reversing section.
But for now, we haven't talked about this.
So we stick to the to the convenient source code.
All right, let's open this one.
Not this one.
This one.
So the first view should be into the Android manifest and here we have it.
It's a little bit harder to read for me, but I guess we can still do this.
You know what?
Let's get out a graphic tablet and have a look into this one.
Okay.
So here we are back on the graphic tablet.
Now let's have a look into this one.
So let's see, how many activities do we have?
We've got one over here.
We've got one here.
And this is another one.
This one we can see this one has an intent folder and this intent folder is listening to the action
main and has this category launcher, which means if you click on this icon on our smartphone, this
intent will be sent.
So this application is listening to our smartphone or into our smartphone, and it's waiting for this
intent.
So this is our message intent that appears when when we click on a website or when we click on our icon
this way, then we will start this activity.
So this one is our first one.
Okay, let's get rid of my annoying drawings and then we've got this user profile.
There's nothing special about this one.
It's not exported.
It's simply just an activity showing our user profile.
All right, so that was easy.
But then we've got this one over here, the third one, and this one is exported through.
And we also got an intent folder.
So let's see, this intent folder is waiting for an action change pin.
This is our action.
And it also has this category default.
This category default.
I guess we have to look it up because I have already forgotten what this one does, but it's related
to activities.
So I guess if you want to start an activity, we need to have a category default to to open it.
Otherwise, if we, if it triggered this action without having this category, the action or this this
intent will be sent.
But the activity, this change pin activity won't open on our smartphone.
So if I remember correctly, this was the case regarding to this one.
Therefore, with the category default, we also tell you, tell the smartphone, please open this this
change pin activity.
And it's also exported, explicit and over here, implicit, which means we can trigger this from the
outside world.
This sounds absolutely amazing, right?
Definitely.
So we will have and look into this one.
But first, let's start with the main activity and let's see what what intents we've got in here.
So therefore let's switch back.
Alrighty.
So let's get rich.
Yes.
So we start with the main activity.
Oh, yes.
I didn't expect that much content right now.
So yeah, it's already mentioned this is not an app development course.
But nevertheless, let's talk about a little bit of this because the more you see, the more you get
familiar with this stuff.
Okay.
So the little bit version did extend into an one hour long video and I guess no one wants to watch this.
If you want to talk about intent filters, therefore, in case if you are interested in reverse engineering
this line by line, then simply drop in comment under this video over here and I will upload the extended
version also as in video.
Okay.
For now, we really focus only on the most important parts right now, but nevertheless, we take a
little bit of a look around all these Android components.
Okay, so therefore let's go over here.
We've got simply two variables.
There's nothing special about them.
It's simply just two strings.
Okay.
And then we've got these added text fields, those two.
And this is a little bit interesting within an Android application, I guess it's a good idea if we
take the application on the right and then we have it and now added text fields are things like this
and this.
So these are fields where we can put our text into and those texts will be referenced by those two objects
right now.
So this one is our user and this one over here is our pass.
Okay.
Then we've got the context and the context.
I mean, it took me it took me weeks to understand the concept behind this, but the context is simply
just the red dot on the map which which tells us you are here right now at the moment.
So the context is telling the application you are right now in the main activity because this information
is required if we are interacting with other components, for example, services, broadcast receivers
or broad content provider or also if are having some UI interactions, then we need to know where we
want to put this UI on which screen we are putting this right now.
And this is the context.
So the context is simply just the reference.
We are here right now.
Okay.
All right.
Next, we've got the shape preferences and preferences.
I mean, this is an it's in file and text file and XML file within the data data directory.
So our application has an protected directory within the data data section.
And within this directory we can store we can store files like the share preferences.
So this file will be protected.
It's not possible to access this from another application.
This one, for example, unless we are having higher privileges route or some system services are also
able to access this file.
So in case if we store some sensitive information, for example, user credentials, pins, password
or things like this, I wouldn't count this as a vulnerability itself if we need higher privileges to
have to have look into this file.
But in case if you store in some generic values in there, then it's a different story.
So let's say this file contains some default credentials and these default credentials can be used to
access other applications.
So on different smartphones, this application, for example, this one over here on another smartphone,
then I would count this as vulnerability, because this is an information an attacker has access to.
All right.
Okay, then let's see.
Then we've got you on Create Method and the on create method.
Let's clean this up a little bit.
The on create method is simply just creating the screen content and this one over here.
So everything that's placed over here is being defined in your own create method.
Because here we've got the layout and we are also assigning now this stuff here for example, we assign
in the context which is related now to the main activity, main activity.
And over here we are assigning those two fields.
So this one and user and this one into the passport variable or in this case object.
Okay.
And then you've gotten in that PIN method, but we do not take care about this one right now.
Next, we've got the log in function, this one.
And now it's becoming interesting.
The log in function seems to be connected to this button.
This means if you are pressing this button, this function will be trigger.
And this is something we need to look up in the in the layout of this activity.
So if you reverse engineer an application, we need to have a look into the activity main and layout
this one.
Mitch is located over here.
And then we have to we have to look for an on click method or within the Java code for and set on click
listener.
If you find this log in method in there, then we know if you press this button in this one, this method
will be triggered.
Okay.
And this is a method we are going to analyze a little bit further right now.
So let's clean this up.
Okay.
So here we can see we are fetching the user name from our this one is our added text field in this one
also.
And we're getting now those two into these two variables.
Okay.
U.S. passed and now we make the we make a comparison if our username this one over here is equals admin
and if our pin is equals the return value of this method.
This method is being defined over here and this method is simply just looking up the value which has
been stored in the shared preferences file.
So within the data data directory, the protected directory.
So within that there will be our pin stored and we are simply getting this information in case if we
haven't defined a pin right now.
So if we have simply just installed this application and it's our first run and then we are assigning
an default value which is one, three, three seven.
So this is our initial pin value and we can see over here, if you want to modify this file to share
preferences, we're using shared preferences, edit the edit function and then we are using put string
to apply our data.
And if you want to read from this file, we are simply doing it in this way over here.
So here we can see why we are using the context, because the context is now defining.
We want to access this file in this one from the main activity of our what's the name, the alarm pin
application.
So this is the that's the data storage of the alarm pin application.
And by using context capture preferences, this final's okay, we want to access this file from the
main activity of our lamp pin application and we are allowed to do this because this one over here,
this is the protected data directory of the application itself.
So this is something, this is why we can access it and then we call get chat preferences and we call
this for the string pin.
So the values in this file are being stored in an XML key value pair.
So this one over here is our key.
And this key has some value in our case.
Right now the key is pin and the value would be now for example, one, three, three, seven.
Okay, so we assign this whole key value pair now to the shared preferences instance and we can now
access this field, this string in the following way.
We are calling in return, share preferences, get string, and then we want to have the string of the
key pin which is 13371 case if no pin has been defined default.
So this is our default value over here, which means if knock loop sorry, if now key has been found,
then we are returning now.
Okay, so that's the whole metric behind those shared preferences.
Okay.
But that's all right.
Now regarding to Android app development, because we are interested in intents, but nevertheless,
this is this is definitely something you should look for if you analyze an application.
All right.
So let's clean the screen and now let's get back.
So if you're not providing the correct credentials, username, admin and the correct pin, in our case,
the default pin is 1337.
If the user hasn't changed this, we are entering this function.
Otherwise we are simply just printing out in text.
The pin is incorrect.
Okay, but now within this function we can see we've got this intent and now it's getting interesting.
So we can see we've got intent, new intent.
And here we are defining now a new message object.
So this message object may be sent from our this class, which is the main activity.
So this is our main activity and we are sending this right now or we want to start the user profile
class.
So we want to start a new activity, which is the user profile.
And this would be even enough.
So this is our intent.
And we could simply use start activity with our intent to trigger this.
So our main activity would call the user profile.
The main activity gets deleted from this tag and the user profile appears over here on the screen.
But now we are also providing some information to our user profile activity.
Let's see, what are those information?
Let's clean this up.
The information they are providing are within intent.
Put extra and we can see once again we are having this key value pair.
So we've got this username.
This is our key.
And the username has the value admin.
So these information are now being packed into our intent and it will be also delivered to the user
profile activity.
So sorry for this one.
Okay, so here we are now having our intent and this contains now our username username which is admin.
And this information will be now passed to the user profile activity.
Okay.
So let's see what the user profile activity is doing with this information and therefore let's clean
this up and let's have a look over here.
Okay.
Within the user profile, maybe we should log in and then we can see this.
Okay.
So here we have now the user profile and this one.
There we go.
And this is our user profile and we can see right now in this line.
So here we are fetching the intent.
This was the message object from the main activity.
We are fetching this intent and we are simply we are initializing our own intent with the values from
this one.
So we're simply calling the method get intent, and then we are assigning this intent over here.
So now we have access to the information which has been provided in this intent.
And those information were, let's see, over here, we can see we are assigning now to our variable
user name the value from our intent.
So we're using intent get string extra in this part.
And if you want to have the string from our key username.
So with in our intent we are having the information.
Maybe let's take an embed color.
Let's say green.
There we go.
So over here we've got the information username and the value is admin.
So username is our key.
Barely readable, but I guess it's still good.
So this is our key.
And this one over here is our value.
And we are now getting the value from our key username and assign this to this one.
And then we can see we are calling text view set text for our username, which is exactly what we are
seeing over here.
So this is now our username admin, which has been passed from the main activity to the user profile
activity over here.
All right.
Okay.
So this is how we can pass information from one activity to another.
And also over here, we are doing it once again because we've got the method change settings.
This one is being connected to this button and here we can see we are now passing from our user profile
activity.
Another intent.
With some information to the next activity, which is the change spin class, which information have
you are passing to this form?
And let's have a look once again, let's clean this up a little bit here.
We've got our intent and here we've got intent.
Put extra.
So we're putting some extra information into our intent.
And once again, we are forwarding the user name which has been assigned over here, which comes from
the main activity.
So the user name from the main activity will be passed to this user profile class.
And from here we are also passing it to the change pin class.
This part over here.
Okay.
And then we are calling this this state activity intent, which opens now or deletes the user profile
activity and opens the change pin activity.
So this is also the reason why we see this username in our change pin activity.
So let's clear this real quick, okay?
And let's see if we click change pin, then we can see this admin field over here.
And if you go into this class.
Oh, let's see.
There's a lot of stuff.
Yes.
So here we have now some interesting behavior.
Okay.
So first of all, we've got this intent over here.
So once again, we are getting this intent which comes from the user profile class right now, and we
assign this to our user name.
So we once again fetch the D value for the key user name.
This is our key and we are fetching the value which is admin and we store this into a local variable
username.
Okay.
And then over here we've got the change pin method.
And what this change pin method is doing is the following.
It takes the text from the pin.
So over here we can see we having added text, get text to string.
So we're getting whatever we have inserted over here into the variable pin and then we are opening the
share preferences.
So we're getting a reference to the share preferences and then we check if our username is equals null.
If we do not provide a username, then let's see what happens.
Only factory reset will be possible.
So this means if we are not providing any username for this activity, the only thing we can do is the
following.
Here we are opening the share preferences in an editor mode and we applying the the default pin 1337
to our shared preferences.
Fine.
And then we simply, we simply print out the message reset successful.
So here we cannot define a new pin.
We can simply just reverted back to the, to the default pin.
And this might be a pin that an attacker does not know.
So it could be some kind of QR code printed on the back of the alarm system.
The user has the information for this one, but not the attacker.
This means an attacker which is not providing a username to this one over here cannot cannot change
the pin.
The attacker can only do a factory reset for the pin, but this might not help further.
So the attacker might not get an advantage out of this one because the attacker does not know the default
pin.
Alrighty.
Okay.
In case if you're providing a username to this one, then let's see once again share preferences.
Editor And then we're putting our pin, which has been fetched from this one over here.
So from our edit text field, this is our pin right now.
We are putting this into the shared preferences file, which is within the protected data data directory.
This is our new PIN and we have seen at the beginning of this application that this pin will be used
to log in into the application.
So if we can provide a user name to this file, then we can override the pin.
It's now unclear if we have to provide a certain username because this is an edge case, which means
we could provide any username.
It doesn't have to be null, but I mean, that's okay if you are providing test.
It should also work because there's only one pin available right now.
Alrighty.
Maybe not, but I guess let's simply let's try exploiting this right now.
So maybe let's have a quick look into this function at the beginning.
But I guess we we didn't miss an important stuff.
Yes.
So here we can see we're just assigning those, those fields and edit text and text, view and button.
And these are those fields.
Let's see, this is our edit text.
And this one and this one is our text view.
And this one is.
Last but not least, our button.
This me already talked about this part and here we can see.
Okay, if the username is not equal to null, we set it to username.
Otherwise we we disable this button.
So this part would be disabled if the username username is null.
But I guess this is something we can easily try out right now.
Okay.
All right.
And I guess that's all for this for this functionality.
Let's see.
Yes.
This is the part we have already talked about.
Okay.
So now I would suggest let's try exploiting this.
So let's see, how can we exploit this?
If you take a look into the Android manifest XML, we have figured out that this this change in function
is exported.
Okay.
So the thought process behind this of the developer might be the following.
We've got our main activity.
And from there, if you log in with the correct credentials here, we've got our username and pin.
We are opening the user profile activity in this one and here we can now change the pin which opens
the the change pin activity in this one.
So if we have been locked in into this application, we are having a user profile, which means here
we are now having this this username in this case for example, admin.
And if you hit the change pin button, then we are changing the passport or the pin for our user right
now, the admin user in case if the user has forgotten the pin and this one has been exported.
So it could be also triggered from another application for example, and pin reset application.
So let's say here we are having our our pin reset app, this pin reset app.
You can open the exported activity, but the pin reset might not be able to provide an username for
this one, which means if no username has been provided, we can only reset the pin to end to default
factory value, which is not known to this application or to an attacker right now.
So this might be printed at the back of the alarm system.
This might be the thought process behind this.
But of course this is not true because we as an attacker, we could simply we could create our own application.
This is our malicious application.
And now we could also open this export activity, but we can provide and use our name, which means
we are not using the reset function anymore.
We are using the change pin function for this username.
So this was a really good example which I have encountered exactly like this in a real world application.
So this is something that can happen.
Okay.
So from the perspective of the developer, if we are not able to provide additional information based
on an intent, yes, then this approach would work.
Unfortunately, this is possible and this is something we are going to explore right now.
So let's see how we can do this.
Okay.
To exploit this, we are using the activity manager and we are simply triggering this intent.
So the action change pin and the category default.
So let's see, we are opening and in terminal and we are using the ADB shell and now within the activity
manager, we've got all the information we need so we know how to start an activity am start activity
and this time we do not necessarily need an component name.
So we could provide one component name which is regarding to this activity.
But we can also do this based on this intent folder.
So this one over here, this would be an explicit intent and this one over here would be an implicit
intent.
We do not know the destination which application wants to open this, but in case if only one application
has been registered to this event, then yeah, it will open.
Okay, so let's do both.
We, we start with an explicit intent and we're calling the change pin functionality.
So Dash and then we need our package name.
Slash and then change pit.
Okay, let's open the smartphone and let's do this in three, two, one and on command, start activity.
Let's see.
Yes.
There a typo.
Now let's do this in 3 to 1.
Okay.
And here we can see if no user has been selected, the pin will be reset.
So if we click reset, then the PIN Reset has been successful.
And yes, once again, we are having the 1337 pin and that's verify this.
Yes.
Okay, perfect.
It works.
So here we can see this is how we can reset the pin.
And this one over here.
This is an it's an explicit intent because we have defined the exact destination we want to call it.
All right.
Now let's do this based on an implicit intent, which would be the following.
So, yes, let's make this a little bit smaller.
We are now defining an intent and we do not describe the application which is executing it.
We are just describing the intent, which is this one over here.
So this application is listening to the into the smartphone.
Oh, okay.
I guess my ears are getting worse right now.
It's listening to the smartphone and it's waiting for an action change pin.
So this isn't custom intent right now.
We can see this based on the package name.
It's not an Android specific one, it's an custom one.
And besides this action, this content also needs to have this category.
Okay, so let's see how we can do this.
Okay.
So we are calling AM start activity and this time we are using this information provided over here.
So here we can see this is how we can define an action.
A Here we have this dash for data and we've got this dash see for category.
So if you want to trigger this intent, all we need to do is simply use AM.
Start activity.
Dash A and then let's see.
Let's copy this.
From this change pin.
And the category is over here.
Okay.
And now, if you are opening our applications, let's close this maybe.
Okay.
So we are within the lock in right now, and now we trigger this implicit intent in 3 to 1.
All right.
Same behavior, but different intent.
In the first one, we have exactly defined which application of which activity we want to call.
In this case, right now, we have defined the intent, and this is the only application which is reacting
to this one.
So to this action, come a pecking change pin with this category.
I'm not sure if he if you require this category to be honest, but I guess the activity won't be open.
Let's see.
Oh, it's still working.
So we can see it's opening.
It is enough to.
Yeah.
To address this based on an action.
All righty.
So this is the difference between an explicit and an implicit intent.
I have another example afterwards.
But first, let's exploit this right now.
So how can we do this in the change in activity we have seen by using this intent, get intent, and
we have seen we are fetching this key.
So within our intent, we are fetching the key username and we are signing the value to our variable
which will be checked in our code over here in the tool to provide this as in text and also over here
to make the decision if we are resetting this app so the pin or if we simply if we are simply taking
this pin into our shared preferences.
And this is a decision we can influence right now because we can define a username for this variable.
This will be assigned over here.
So all we need to do is we need to put this information into our intent and key username within certain
value.
How can we do this?
The answer is over here.
So if you zoom out a little bit here, we can see we've got this extra, extra key and here we can see
by applying dash.
Dash is or simply just E, we can define a new key and a new value.
With E set, we can define a new key and a boolean value.
Dash II gives key and integer value.
So the last letter defines what type we are defining right now.
In our case, our username is from type string, so we are simply defining an in string value for this
one.
So let's see.
Oops.
Did that change something?
I hope not.
Okay, let's clear this.
And now let's take the last command.
Let's maybe opening the help here.
Yes.
Okay.
So with that stash is we are now telling our intent, please pack some information into our intent and
we want to have a username.
Those quotes are not required I guess, but I keep doing it, so please don't ask.
Okay.
So this is our key.
And now let's say, for example, test, okay, let's put this smartphone on the right and let's do
this once again.
Nice.
We can see now the application has behaved differently.
So it did react to our intent with our additional information.
The test is being printed out over here.
I mean, we are not having some kind of interaction points.
So that's not we cannot insert stuff like this reflected cross-site scripting because this is not it's
not in that browser.
But I mean, yes, we might be able to use this for some kind of phishing.
For example, your password has been hacked.
Please change it over here.
So then the user might find a new password.
But I mean, we do not get an advantage out of this because the user is just defining a new password
for its own application.
But nevertheless, this is how we can interact with this application in case if we are having multiple
intents or not intense values in our intent.
Let's see.
Yes.
If you're having some additional one, let's.
Let's do it.
Maybe this way.
PIN,
then we simply can we can put them together.
So over here we are having this username.
Let me close this in the background.
These are those processes.
Okay, it's closeness.
Okay, so now we.
We can read this a little bit easier.
So here are having the user name test.
And then we could also do this for example.
Okay.
So this is how we can apply multiple strings into our values, into our intent.
In case if we're having an integer, we have to use it in the following way.
Alrighty.
Okay.
So yeah, if we are providing additional intents which our application does not react to because this
is not all originally included, then it simply just gets ignored.
Okay.
Now let's see if we can change the pin over here.
So we have this test
and let's name the.
And now, let's see, we defined a new pin, which is one four, seven, eight, nine send.
PIN up.
They did successful.
Okay.
Looks good.
Let's close this application.
And let's reopen it.
I mean the username is now still admin.
It's not hacked, but let's see if we have overwritten the pin for this user.
14789.
Yes.
Nice.
So we have overwritten the pin for this user because there's only one pin entry available.
Therefore the user name doesn't matter anymore.
It's just required.
And if it's not, then this won't work.
But if we can apply any user value, then we are overriding the pin.
Alrighty.
Okay.
Amazing.
Right.
So maybe let's have a quick look into this file.
So within the ADB shell root privileges and then within data data.
Com app hacking alarm pin intense sniffing is something we take a look into in a moment right now.
So don't worry.
Even now having these shared preferences, A.B having our PIN example and here we have it.
Yes, we can see we have overwritten the pin.
All right.
So this is the that symbol ability in this application and reacting to activities.
I mean, it's not that it doesn't occur often anymore.
It can still be possible, but it doesn't happen often.
Regarding to broadcast receivers, this is a different story.
So within broadcast receiver, this can still occur pretty often.
This is something you should definitely check out and this is also something we will discuss heavily
in the broadcast receiver topic.
Alrighty.
Okay.
One last example regarding to implicit intents, because I find this pretty ridiculous sending out an
intent without knowing which application reacts to this one.
And let's assume we've got multiple applications.
What happens then are opening all or how has it been handled?
This is something we are going to take a look into right now.
And afterwards, within a new video, we are talking about intent sniffing.
So therefore, we are still not done right now.
Okay, so let's close this.
All right.
We have already seen this implicit intent.
So within the Android manifest example, we have sent this intent and luckily there was only one application
which has been registered to this one because this isn't custom intent.
But what happens if you're sending out an intent where many applications has been registered to and
let's find this out.
So what we can do is we can do the following.
Okay, so we are using once again our activity manager and now we are sending out an intent which is
used by many applications, which could be, for example, an action Android intent action view.
So this is in common action for an intent and we can also apply a category, this one over here.
So there are many applications which has been registered to this event.
So let's put all or pull this smartphone in the box.
Let's put the smartphone in the foreground and let's see what happens if we are triggering this.
I'm executing this in 3 to 1.
And.
Oh, interesting.
So here we can see we've got one application, intense sniffing, which might have been used before,
but also all these other applications has been registered to this event.
So these are now all applications which has been registered, and all of them are telling the smartphone,
hey, your request, I can handle this, and the user has not a choice to open the application.
So it's about the user to make the decision which one should, should react to this event.
For example, this calendar, then the calendar app will be opened or will react to this event and all
others are simply just ignoring it.
Okay.
So this is the that's the concept behind an implicit intent sending out an event without knowing which
application is going to open.
The other one is the explicit intent.
And this is something we have seen over here.
So let's see this one.
So here we are defining the exact package name which should serve this event.
And this is something we cannot sniff.
So if we are calling an explicit intent, if we tell this application, this change in activity to open
it, we can, of course, also provide some data.
But this is an information that cannot be sniffed by another application regarding to implicit intents
like this one.
This is a different story.
So if the user miss clicks, then the attacker will have the information.
Alrighty.
Okay.
If you have any questions regarding to this one, please drop me a message in the in the comment section
and otherwise.
I'm looking forward to see you in the next part.