Va bene, ragazzi.
Quindi, ancora una volta, dopo tutta la teoria.
Ora cerchiamo di avere una visione pratica di questo argomento e di fare qualche esercizio e qualche pratica,
perché altrimenti è davvero difficile da afferrare.
Giusto.
Pertanto, diamo un'occhiata a Ubuntu VM e ho preparato una bella applicazione per voi.
Come sempre, potete scaricare l'intero codice sorgente come allegato della sezione, perché abbiamo già dato
un'occhiata al reverse engineering e l'applicazione si inserisce nel nostro argomento sui sistemi di allarme.
E anche se mancano, diciamo, alcune funzioni, abbiamo un caso d'uso che ho riscontrato in un'applicazione
reale.
Si tratta di un aspetto che voglio mostrare in questa applicazione, diciamo di mocking.
Bene, diamo un'occhiata.
Quindi ho già lo smartphone in funzione.
Abilitiamolo.
E se scorrete verso l'alto, abbiamo questa fantastica app sveglia.
Quindi questa volta mi sono impegnato un po' nel layout e spero che vada bene.
Quindi non importa.
Voglio dire, questa combinazione di colori.
Sì, esaminiamo questo aspetto.
Quindi abbiamo ottenuto la registrazione e abbiamo ottenuto nome utente e password.
Vi dirò quindi quali sono queste caratteristiche.
Il nome utente è admin e la password.
È un pin, composto da numeri e credo che la password iniziale sia uno tre, tre,
sette, ma.
Se si fa clic su login?
Sì.
Funziona ancora.
Ho pensato di aver giocato un po' troppo con questo, ma sì, eccolo qui.
Quindi, dopo l'accesso, dobbiamo verificare se ogni pin può essere accettato, perché ho scritto questa applicazione,
ma supponiamo che l'utente abbia un pin e dobbiamo conoscere questo pin.
Poi si passa all'attività successiva, che ora è una sorta di attività di profilo.
E qui possiamo cambiare il perno.
Possiamo anche vedere che abbiamo questo campo admin qui, questo.
Quindi dalla prima attività ci saranno già dei dati passati in questa attività.
Il nome utente e questo accade ancora una volta se si fa clic su Cambia PIN, se si fa clic su Cambia PIN,
si può vedere il nome utente.
Anche l'amministratore sarà passato a questa applicazione e ora possiamo cambiare il pin di questo amministratore, ad esempio.
Uno, due, tre, quattro.
E se si clicca su invia.
PIN aggiornato con successo poi typo no oc perfetto.
Quindi, se chiudiamo l'applicazione, ci liberiamo di questa riga.
E se lo state aprendo ancora una volta, vediamo se le mie capacità di programmazione sono davvero così buone.
Nome utente admin password.
Uno, tre, tre, sette.
Effettuare il login.
Il PIN non è corretto.
Perfetto.
Così si può vedere questo.
Anche questo sopravvive al riavvio di questa applicazione.
Quindi abbiamo qui alcuni contenuti di file.
Ok, inseriamo questo pin.
Ed ecco l'attività successiva.
Diamo un'occhiata al codice sorgente, perché così vedremo come queste informazioni
verranno passate da un'attività all'altra.
Una domanda per questo.
Si tratta di un intento implicito o esplicito?
Assolutamente corretto, ragazzi.
Si tratta, ovviamente, di un intento esplicito, perché sappiamo quale destinazione vogliamo chiamare.
In questo caso, si tratta di un'attività di profilo.
E se si fa clic su Cambia pin, l'attività cambia pin.
Quindi conosciamo la destinazione.
Vogliamo andare.
Va bene.
Diamo quindi un'occhiata al codice sorgente.
E come sempre, potete trovare il codice sorgente come allegato della sezione finché non parliamo
di reverse engineering, allora non avrete più il comodo codice sorgente, perché a quel punto
dovremo farlo da soli.
Va bene.
Naturalmente, è possibile iniziare a farlo anche adesso con lo strumento "excuse me" o con gli altri strumenti menzionati nella
sezione dedicata all'inversione.
Ma per ora non ne abbiamo parlato.
Quindi ci atteniamo al comodo codice sorgente.
Bene, apriamo questa.
Non questo.
Questo.
Quindi la prima vista dovrebbe essere nel manifest di Android ed eccolo qui.
Per me è un po' più difficile da leggere, ma credo che possiamo ancora farlo.
Sapete una cosa?
Prendiamo una tavoletta grafica e diamo un'occhiata a questo caso.
Ok.
Eccoci quindi tornati alla tavoletta grafica.
Ora diamo un'occhiata a questo.
Vediamo, quante attività abbiamo?
Ne abbiamo uno qui.
E questo è un altro.
Possiamo vedere che questa ha una cartella di intenti e questa cartella di intenti è in ascolto dell'azione principale e ha questo
lanciatore di categorie, il che significa che se si fa clic su questa icona sul nostro smartphone, l'intento verrà
inviato.
Quindi questa applicazione sta ascoltando il nostro smartphone o il nostro smartphone e sta aspettando questo
intento.
Questo è l'intento del messaggio che appare quando si fa clic su un sito web o quando
si fa clic sulla nostra icona.
Questo è il nostro primo lavoro.
Ok, eliminiamo i miei fastidiosi disegni e poi abbiamo questo profilo utente.
Non c'è nulla di speciale in questo.
Non viene esportato.
È semplicemente un'attività che mostra il nostro profilo utente.
Bene, è stato facile.
Ma poi c'è questo qui, il terzo, e questo viene esportato.
E abbiamo anche una cartella delle intenzioni.
Quindi, vediamo che questa cartella degli intenti è in attesa di un pin di modifica dell'azione.
Questa è la nostra azione.
E ha anche questa categoria predefinita.
Questa categoria è predefinita.
Credo che dovremo cercarlo perché ho già dimenticato cosa fa questo, ma è legato
alle attività.
Quindi, se si vuole avviare un'attività, è necessario avere una categoria predefinita per aprirla.
Altrimenti, se si attiva questa azione senza avere questa categoria, l'azione o questo intento
verrà inviato.
Ma l'attività, questa attività di cambio pin non si apre sul nostro smartphone.
Quindi, se ricordo bene, questo era il caso di questo.
Pertanto, con la categoria predefinita, vi diciamo anche, dire lo smartphone, si prega di aprire questo questo cambiamento
attività pin.
Ed è anche esportato, esplicito e qui, implicito, il che significa che possiamo attivarlo dal mondo
esterno.
Sembra assolutamente fantastico, vero?
Sicuramente.
Quindi dovremo esaminare questo aspetto.
Ma prima, iniziamo con l'attività principale e vediamo quali sono gli intenti che abbiamo qui.
Torniamo quindi indietro.
Va bene.
Quindi diventiamo ricchi.
Sì.
Iniziamo quindi con l'attività principale.
Oh, sì.
Non mi aspettavo così tanti contenuti in questo momento.
Quindi sì, è già stato detto che questo non è un corso di sviluppo di app.
Ma comunque, parliamone un po' perché più si vede, più si familiarizza
con queste cose.
Ok.
Quindi la versione ridotta si è trasformata in un video di un'ora e credo che nessuno voglia guardarlo.
Se volete parlare dei filtri di intento, quindi, se siete interessati a fare il reverse engineering
riga per riga, lasciate un commento sotto questo video qui e caricherò anche la versione estesa
come nel video.
Ok.
Per ora ci concentriamo solo sulle parti più importanti, ma diamo comunque un'occhiata
a tutti questi componenti di Android.
Ok, quindi passiamo a questo punto.
Abbiamo semplicemente due variabili.
Non hanno nulla di speciale.
Si tratta semplicemente di due corde.
Ok.
E poi abbiamo aggiunto questi due campi di testo.
E questo è un po' interessante all'interno di un'applicazione Android, credo
che sia una buona idea se prendiamo l'applicazione sulla destra e la facciamo aggiungere ai campi di testo cose
come questa e questa.
Si tratta quindi di campi in cui possiamo inserire il nostro testo e i testi saranno referenziati da questi due
oggetti.
Questo è il nostro utente e questo qui è il nostro pass.
Ok.
Poi abbiamo il contesto e il contesto.
Voglio dire, mi ci sono volute settimane per capire il concetto che c'è dietro, ma
il contesto è semplicemente il punto rosso sulla mappa che ci dice che siete qui in questo momento.
Il contesto indica all'applicazione che ci si trova in questo momento nell'attività principale, perché questa informazione
è necessaria se si interagisce con altri componenti, ad esempio con i servizi, i ricevitori di broadcast o con un ampio fornitore
di contenuti, oppure se si hanno interazioni con l'interfaccia utente, per cui è necessario sapere dove si vuole collocare l'interfaccia
utente, su quale schermo la si sta collocando in questo momento.
E questo è il contesto.
Quindi il contesto è semplicemente il riferimento.
Siamo qui in questo momento.
Ok.
Va bene.
Poi, abbiamo le preferenze di forma e le preferenze.
Si tratta di un file e di un file di testo e di un file XML all'interno della directory dei dati.
Quindi la nostra applicazione ha una cartella protetta all'interno della sezione dati.
All'interno di questa directory possiamo memorizzare file come le preferenze di condivisione.
Quindi questo file sarà protetto.
Non è possibile accedervi da un'altra applicazione.
Questo, ad esempio, a meno che non si disponga di un percorso con privilegi più elevati o che alcuni servizi di sistema non siano in
grado di accedere a questo file.
Quindi, nel caso in cui si memorizzino informazioni sensibili, ad esempio credenziali utente, pin, password o cose
del genere, non la considererei una vulnerabilità in sé, se abbiamo bisogno di privilegi più elevati per poter dare un'occhiata
a questo file.
Ma se si memorizzano alcuni valori generici, la storia è diversa.
Supponiamo che questo file contenga alcune credenziali predefinite e che queste credenziali predefinite possano essere utilizzate
per accedere ad altre applicazioni.
Quindi, su smartphone diversi, questa applicazione, ad esempio, questa qui su un altro smartphone, la considererei
una vulnerabilità, perché si tratta di un'informazione a cui un aggressore ha accesso.
Va bene.
Ok, allora vediamo.
Poi abbiamo il metodo Create e il metodo Create.
Ripuliamo un po' il tutto.
Il metodo di creazione è semplicemente la creazione del contenuto dello schermo e di questo qui.
Quindi, tutto ciò che è posizionato qui viene definito nel proprio metodo create.
Perché qui abbiamo il layout e stiamo anche assegnando queste cose qui, per esempio,
assegniamo il contesto che è collegato all'attività principale, l'attività principale.
E qui assegniamo questi due campi.
Quindi questo e l'utente e questo nella variabile passaporto o, in questo caso, nell'oggetto.
Ok.
E poi avete inserito il metodo PIN, ma non ci occupiamo di questo al momento.
Poi c'è la funzione di accesso, questa.
E ora sta diventando interessante.
La funzione di accesso sembra essere collegata a questo pulsante.
Ciò significa che se si preme questo pulsante, la funzione verrà attivata.
Questo è un aspetto che dobbiamo verificare nel layout di questa attività.
Quindi, se si esegue il reverse engineering di un'applicazione, è necessario dare un'occhiata all'attività principale e al layout
di questa.
Mitch si trova qui.
E poi dobbiamo cercare un metodo on-click o all'interno del codice Java per impostare un ascoltatore on-click.
Se si trova questo metodo di accesso, allora sappiamo che se si preme questo pulsante in questo, questo metodo
verrà attivato.
Ok.
Si tratta di un metodo che ora analizzeremo un po' più a fondo.
Quindi, facciamo un po' di pulizia.
Ok.
Qui possiamo vedere che stiamo recuperando il nome dell'utente dal nostro questo è il nostro campo di testo aggiunto anche
in questo.
E ora le inseriamo in queste due variabili.
Ok.
U. S. passato e ora facciamo un confronto se il nostro nome utente,
questo qui, è uguale ad admin e se il nostro pin è uguale al valore di ritorno di questo metodo.
Questo metodo viene definito qui e non fa altro che cercare il valore memorizzato nel file
delle preferenze condivise.
Quindi, all'interno della directory dei dati, la directory protetta.
Quindi, all'interno di questo ci sarà il nostro pin memorizzato e stiamo semplicemente ottenendo queste informazioni nel caso in cui non abbiamo definito
un pin in questo momento.
Quindi, se abbiamo appena installato questa applicazione ed è la prima volta che la eseguiamo, assegniamo
un valore predefinito che è uno, tre, tre sette.
Quindi questo è il nostro valore iniziale del pin e possiamo vedere qui, se volete modificare questo file
per condividere le preferenze, stiamo usando le preferenze condivise, modificando la funzione di modifica e poi stiamo usando put string per
applicare i nostri dati.
E se si vuole leggere da questo file, lo si fa semplicemente in questo modo qui.
Qui si capisce perché stiamo usando il contesto, perché il contesto ora si sta definendo.
Vogliamo accedere a questo file dall'attività principale della nostra applicazione di
allarme.
Questo è l'archivio dei dati dell'applicazione del pin di allarme.
Utilizzando le preferenze di cattura contestuale, questo finale va bene, vogliamo accedere a questo file dall'attività
principale della nostra applicazione lamp pin e siamo autorizzati a farlo perché questa qui è la directory
dei dati protetti dell'applicazione stessa.
Quindi questo è qualcosa, ecco perché possiamo accedervi e poi chiamiamo get chat preferences e chiamiamo
questo per la stringa pin.
Quindi i valori di questo file vengono memorizzati in una coppia chiave-valore XML.
Questa qui è la nostra chiave.
E questa chiave ha un certo valore nel nostro caso.
In questo momento la chiave è pin e il valore sarebbe, ad esempio, uno, tre, tre, sette.
Ok, ora assegniamo l'intera coppia chiave-valore all'istanza delle preferenze condivise e possiamo accedere a
questo campo, questa stringa, nel modo seguente.
Stiamo chiamando in return, share preferences, get string, e poi vogliamo avere la stringa
del pin della chiave che è il caso 13371 se non è stato definito un pin predefinito.
Quindi questo è il nostro valore predefinito qui, il che significa che se il ciclo knock sorry, se ora la chiave è stata trovata, allora stiamo
tornando indietro.
Ok, questa è la metrica alla base delle preferenze condivise.
Ok.
Ma non c'è problema.
Ora, per quanto riguarda lo sviluppo di applicazioni Android, perché siamo interessati agli intenti, ma comunque
questo è sicuramente qualcosa che dovreste cercare se analizzate un'applicazione.
Va bene.
Puliamo lo schermo e torniamo indietro.
Quindi se non si forniscono le credenziali corrette, nome utente, admin e il pin corretto, nel nostro
caso il pin predefinito è 1337.
Se l'utente non l'ha modificato, si entra in questa funzione.
Altrimenti stiamo semplicemente stampando in testo.
Il perno non è corretto.
Ok, ma ora all'interno di questa funzione possiamo vedere che abbiamo questo intento e ora la cosa si fa interessante.
Quindi possiamo vedere che abbiamo un intento, un nuovo intento.
E qui stiamo definendo un nuovo oggetto messaggio.
Quindi questo oggetto messaggio può essere inviato dalla nostra classe This, che è l'attività principale.
Questa è la nostra attività principale e la stiamo inviando proprio ora o vogliamo avviare la classe del profilo
utente.
Vogliamo quindi avviare una nuova attività, che è il profilo dell'utente.
E questo sarebbe anche sufficiente.
Questo è il nostro intento.
E potremmo semplicemente usare l'attività Start con il nostro intento per attivarla.
Quindi la nostra attività principale chiamerebbe il profilo dell'utente.
L'attività principale viene cancellata da questo tag e il profilo dell'utente appare qui sullo schermo.
Ma ora stiamo anche fornendo alcune informazioni sull'attività del nostro profilo utente.
Vediamo, quali sono queste informazioni?
Ripuliamo tutto.
Le informazioni fornite rientrano nelle intenzioni.
Mettiamo un extra e vediamo ancora una volta che abbiamo questa coppia chiave-valore.
Quindi abbiamo questo nome utente.
Questa è la nostra chiave.
Il nome utente ha il valore admin.
Quindi queste informazioni sono state inserite nel nostro intento e saranno trasmesse anche all'attività del
profilo dell'utente.
Mi dispiace molto per questo.
Ok, quindi ora abbiamo il nostro intento e questo contiene il nostro nome utente, che è admin.
Queste informazioni vengono ora passate all'attività del profilo dell'utente.
Ok.
Vediamo quindi cosa fa l'attività del profilo utente con queste informazioni
e quindi ripuliamole e diamo un'occhiata qui.
Ok.
All'interno del profilo utente, forse dovremmo effettuare il login e vedere questo.
Ok.
Abbiamo quindi il profilo utente e questo.
Ecco fatto.
Questo è il nostro profilo utente e possiamo vedere in questa riga.
Quindi stiamo recuperando l'intento.
Questo era l'oggetto messaggio dell'attività principale.
Recuperiamo questo intento e inizializziamo il nostro intento con i valori di questo.
Quindi chiamiamo semplicemente il metodo get intent e poi assegniamo questo intent qui.
Quindi ora abbiamo accesso alle informazioni che sono state fornite in questo intento.
E queste informazioni erano, vediamo, qui, che stiamo assegnando alla nostra variabile
nome utente il valore del nostro intento.
Quindi, in questa parte utilizziamo l'intent get string extra.
E se si vuole avere la stringa della chiave nome utente.
Quindi, con il nostro intento, stiamo avendo le informazioni.
Magari prendiamo un colore embed.
Diciamo verde.
Ecco fatto.
Qui abbiamo l'informazione username e il valore è admin.
Il nome utente è quindi la nostra chiave.
A malapena leggibile, ma credo sia comunque buono.
Questa è la nostra chiave.
E questo qui è il nostro valore.
Ora prendiamo il valore della chiave username e lo assegniamo a questa.
E poi possiamo vedere che stiamo chiamando la vista text set text per il nostro nome utente, che è esattamente
ciò che vediamo qui.
Quindi questo è il nostro nome utente admin, che è stato passato dall'attività principale all'attività del
profilo utente qui.
Va bene.
Ok.
Ecco come possiamo passare le informazioni da un'attività all'altra.
E anche qui, lo stiamo facendo ancora una volta perché abbiamo le impostazioni di cambio metodo.
Questo viene collegato a questo pulsante e qui possiamo vedere che ora stiamo passando dall'attività del nostro profilo
utente.
Un altro intento.
Con alcune informazioni per l'attività successiva, che è il cambio di classe di spin, quali informazioni avete passato a
questo modulo?
E diamo ancora una volta un'occhiata, ripulendo un po' questo punto.
Abbiamo il nostro intento e qui abbiamo l'intento.
Mettete un extra.
Quindi stiamo inserendo alcune informazioni aggiuntive nel nostro intento.
E ancora una volta, inoltriamo il nome utente che è stato assegnato qui, che proviene dall'attività
principale.
Quindi il nome dell'utente dall'attività principale sarà passato a questa classe di profilo utente.
E da qui lo passiamo anche alla classe change pin.
Questa parte qui.
Ok.
E poi chiamiamo questo intento attività di stato, che apre o cancella l'attività del profilo utente
e apre l'attività di modifica del pin.
Questo è anche il motivo per cui vediamo questo nome utente nell'attività di modifica del pin.
Quindi chiariamo subito la questione, ok?
Se facciamo clic su Cambia pin, possiamo vedere questo campo di amministrazione qui.
E se si entra in questo corso.
Oh, vediamo.
C'è un sacco di roba.
Sì.
Abbiamo quindi un comportamento interessante.
Ok.
Prima di tutto, abbiamo questo intento qui.
Quindi, ancora una volta, otteniamo questo intento che proviene dalla classe del profilo utente e lo assegniamo al
nostro nome utente.
Quindi recuperiamo ancora una volta il valore D per la chiave nome utente.
Questa è la nostra chiave e stiamo recuperando il valore che è admin e lo memorizziamo in una variabile locale username.
Ok.
E qui abbiamo il metodo di cambio del perno.
Il metodo di modifica del perno è il seguente.
Prende il testo dal pin.
Quindi qui possiamo vedere che abbiamo aggiunto del testo, ottenere il testo in una stringa.
Quindi inseriamo qualsiasi cosa abbiamo inserito qui nel pin variabile e poi apriamo le preferenze
di condivisione.
Quindi otteniamo un riferimento alle preferenze di condivisione e poi controlliamo se il nostro nome utente è uguale a null.
Se non si fornisce un nome utente, vediamo cosa succede.
Sarà possibile solo il ripristino dei dati di fabbrica.
Quindi, se non forniamo alcun nome utente per questa attività, l'unica cosa che possiamo fare è la
seguente.
Qui stiamo aprendo le preferenze di condivisione in modalità editor e stiamo applicando il pin 1337 predefinito alle nostre
preferenze condivise.
Bene.
E poi, semplicemente, stampiamo il messaggio reset successful.
Non è quindi possibile definire un nuovo pin.
Possiamo semplicemente tornare al pin predefinito.
E questo potrebbe essere un pin che un attaccante non conosce.
Potrebbe quindi trattarsi di una sorta di codice QR stampato sul retro del sistema di allarme.
L'utente ha le informazioni per questo, ma non l'attaccante.
Ciò significa che un attaccante che non fornisce un nome utente a questo qui non può cambiare il
pin.
L'aggressore può solo eseguire un reset di fabbrica per il pin, ma questo potrebbe non essere di ulteriore aiuto.
Quindi l'attaccante potrebbe non ottenere un vantaggio da questo perché non conosce il pin predefinito.
Va bene.
Ok.
Nel caso in cui si fornisca un nome utente a questo, allora vediamo ancora una volta di condividere le preferenze.
Editor E poi inseriamo il nostro pin, che è stato recuperato da questo qui.
Quindi, dal nostro campo di testo di modifica, questo è il nostro pin in questo momento.
Questo viene inserito nel file delle preferenze condivise, che si trova all'interno della directory dei dati protetti.
Questo è il nostro nuovo PIN e, come abbiamo visto all'inizio di questa applicazione, verrà utilizzato per
accedere all'applicazione.
Quindi, se possiamo fornire un nome utente a questo file, possiamo sovrascrivere il pin.
Ora non è chiaro se dobbiamo fornire un determinato nome utente, perché questo è un caso limite, il che significa che potremmo
fornire qualsiasi nome utente.
Non deve essere necessariamente nullo, ma va bene se si fornisce un test.
Dovrebbe funzionare anche perché al momento è disponibile un solo pin.
Va bene.
Forse no, ma credo che dovremmo semplicemente provare a sfruttare questo aspetto in questo momento.
Diamo quindi una rapida occhiata a questa funzione all'inizio.
Ma credo che non ci siamo persi nulla di importante.
Sì.
Qui possiamo vedere che stiamo assegnando i campi e il testo di modifica e il testo, la vista e il pulsante.
E questi sono i campi.
Vediamo, questo è il nostro testo di modifica.
Questa e questa sono le nostre visualizzazioni del testo.
E questo lo è.
Ultimo, ma non meno importante, il nostro pulsante.
Ho già parlato di questa parte e qui possiamo vederla.
Ok, se il nome utente non è uguale a null, lo impostiamo come nome utente.
In caso contrario, disabilitiamo questo pulsante.
Quindi questa parte verrebbe disabilitata se il nome utente è nullo.
Ma credo che sia una cosa che possiamo provare facilmente in questo momento.
Ok.
Va bene.
E credo che sia tutto per questa funzionalità.
Vediamo.
Sì.
Questa è la parte di cui abbiamo già parlato.
Ok.
Quindi ora suggerirei di provare a sfruttare questo aspetto.
Quindi vediamo, come possiamo sfruttare questo aspetto?
Se si dà un'occhiata al manifest XML di Android, abbiamo capito che questa modifica della funzione
viene esportata.
Ok.
Il processo di pensiero dello sviluppatore potrebbe essere il seguente.
Abbiamo la nostra attività principale.
E da lì, se si accede con le credenziali corrette, abbiamo il nostro nome utente e il pin.
Apriamo l'attività del profilo utente e possiamo cambiare il pin, aprendo
l'attività di modifica del pin.
Quindi, se siamo stati bloccati in questa applicazione, abbiamo un profilo utente, il che significa
che ora abbiamo questo nome utente, ad esempio, admin.
Se si preme il pulsante Cambia pin, si cambia il passaporto o il pin per il nostro utente in questo momento,
l'utente amministratore, nel caso in cui l'utente abbia dimenticato il pin e questo sia stato esportato.
Quindi potrebbe essere attivato anche da un'altra applicazione, ad esempio, e da un'applicazione di reset dei pin.
Supponiamo quindi di avere la nostra app per la reimpostazione del pin, questa app per la reimpostazione del pin.
È possibile aprire l'attività esportata, ma la reimpostazione del pin potrebbe non essere in grado di fornire un nome utente
per questo, il che significa che se non è stato fornito alcun nome utente, possiamo solo reimpostare il pin al valore di fabbrica predefinito,
che non è noto a questa applicazione o a un utente malintenzionato in questo momento.
Quindi questo potrebbe essere stampato sul retro del sistema di allarme.
Questo potrebbe essere il processo di pensiero alla base.
Ma naturalmente questo non è vero, perché noi, come attaccanti, potremmo semplicemente creare la nostra applicazione.
Questa è la nostra applicazione dannosa.
Ora possiamo anche aprire questa attività di esportazione, ma possiamo fornire e utilizzare il nostro nome, il che significa che non stiamo più
utilizzando la funzione di ripristino.
Per questo nome utente utilizziamo la funzione di modifica del pin.
Si tratta quindi di un ottimo esempio che ho riscontrato esattamente come questo in un'applicazione reale.
Si tratta quindi di qualcosa che può accadere.
Ok.
Quindi, dal punto di vista dello sviluppatore, se non siamo in grado di fornire informazioni aggiuntive
sulla base di un intento, sì, questo approccio funzionerebbe.
Purtroppo questo è possibile e lo esploreremo proprio ora.
Vediamo quindi come fare.
Ok.
Per sfruttarlo, utilizziamo il gestore delle attività e attiviamo semplicemente questo intento.
Quindi il pin di cambio azione e la categoria predefinita.
Vediamo quindi di aprire il terminale e di utilizzare la shell ADB e ora, all'interno del gestore delle attività, abbiamo
tutte le informazioni necessarie per sapere come avviare un'attività e questa volta non abbiamo necessariamente
bisogno del nome di un componente.
Si può quindi fornire il nome di un componente che riguarda questa attività.
Ma possiamo farlo anche in base a questa cartella di intenti.
Quindi questo qui sarebbe un intento esplicito e questo qui sarebbe un intento implicito.
Non sappiamo quale sia la destinazione dell'applicazione che vuole aprire questo evento, ma se solo un'applicazione
è stata registrata a questo evento, allora sì, si aprirà.
Ok, allora facciamo entrambe le cose.
Partiamo da un intento esplicito e chiamiamo la funzionalità change pin.
Quindi Dash e poi abbiamo bisogno del nome del nostro pacchetto.
Tagliare e poi cambiare fossa.
Ok, apriamo lo smartphone e facciamolo in tre, due, uno e, a comando, avviamo l'attività.
Vediamo.
Sì.
C'è un errore di battitura.
Ora facciamo questo in 3 a 1.
Ok.
Se non è stato selezionato alcun utente, il pin viene resettato.
Quindi, se facciamo clic su reset, la reimpostazione del PIN è avvenuta con successo.
E sì, ancora una volta, abbiamo il pin 1337 che verifica questo.
Sì.
Ok, perfetto.
Funziona.
Ecco come si può resettare il pin.
E questo qui.
Si tratta di un intento esplicito, perché abbiamo definito la destinazione esatta che vogliamo chiamare.
Va bene.
Ora facciamo questo sulla base di un intento implicito, che sarebbe il seguente.
Quindi, sì, riduciamo un po' le dimensioni.
Stiamo definendo un intento e non descriviamo l'applicazione che lo esegue.
Stiamo solo descrivendo l'intento, che è questo qui.
Quindi questa applicazione sta ascoltando lo smartphone.
Oh, ok.
Credo che le mie orecchie stiano peggiorando in questo momento.
Sta ascoltando lo smartphone ed è in attesa di un pin per il cambio di azione.
Quindi non si tratta di un intento personalizzato al momento.
Lo si può vedere dal nome del pacchetto.
Non è un problema specifico di Android, ma un problema personalizzato.
Oltre a questa azione, il contenuto deve avere anche questa categoria.
Ok, vediamo come fare.
Ok.
Quindi chiamiamo l'attività di avvio AM e questa volta utilizziamo le informazioni fornite qui.
Ecco come possiamo definire un'azione.
R Qui abbiamo questo trattino per i dati e questo trattino per la categoria.
Quindi, se si vuole attivare questo intento, è sufficiente utilizzare AM.
Avviare l'attività.
Dash A e poi vediamo.
Riceviamo questo.
Da questa modifica il perno.
E la categoria è qui.
Ok.
E ora, se state aprendo le nostre applicazioni, chiudiamo questo forse.
Ok.
Quindi siamo all'interno del blocco in questo momento e ora attiviamo l'intento implicito in 3 a 1.
Va bene.
Stesso comportamento, ma intento diverso.
Nella prima, abbiamo definito esattamente quale applicazione di quale attività vogliamo chiamare.
In questo caso, in questo momento, abbiamo definito l'intento e questa è l'unica applicazione che reagisce
a questa.
A questa azione si aggiunge quindi una spilla per il cambio di pettorale con questa categoria.
Non sono sicuro che sia necessaria questa categoria, ma credo che l'attività non sarà aperta.
Vediamo.
Oh, funziona ancora.
Quindi possiamo vedere che si sta aprendo.
È sufficiente.
Già.
Per affrontare questo problema basatevi su un'azione.
Va bene.
Questa è la differenza tra un intento esplicito e uno implicito.
In seguito ho un altro esempio.
Ma prima, sfruttiamo subito questo aspetto.
Quindi, come possiamo farlo nella modifica dell'attività che abbiamo visto utilizzando questo intent, get intent, e abbiamo visto
che stiamo recuperando questa chiave.
Quindi, all'interno del nostro intento, recuperiamo la chiave nome utente e firmiamo il valore nella nostra
variabile che verrà controllata nel nostro codice qui nello strumento per fornire questo testo e anche qui
per decidere se resettare l'applicazione e il pin o se semplicemente prendere questo pin nelle nostre
preferenze condivise.
E questa è una decisione che possiamo influenzare fin da ora, perché possiamo definire un nome utente per questa variabile.
Questo sarà assegnato qui.
Quindi, tutto ciò che dobbiamo fare è inserire queste informazioni nel nostro intento e nel nome utente della chiave entro un certo
valore.
Come possiamo farlo?
La risposta è qui.
Quindi, se si ingrandisce un po', si può vedere che c'è una chiave in più e qui si può vedere che si applica
un trattino.
Dash è o semplicemente E, possiamo definire una nuova chiave e un nuovo valore.
Con E impostato, possiamo definire una nuova chiave e un valore booleano.
Il trattino II fornisce la chiave e il valore intero.
Quindi l'ultima lettera definisce il tipo che stiamo definendo in questo momento.
Nel nostro caso, il nome utente è di tipo stringa, quindi stiamo semplicemente definendo un valore in stringa per questo.
Quindi vediamo.
Ops.
Questo ha cambiato qualcosa?
Spero di no.
Ok, chiariamo questo punto.
E ora prendiamo l'ultimo comando.
Apriamo forse l'aiuto qui.
Sì.
Ok.
Quindi, con questa scorta, stiamo dicendo al nostro intento, per favore, di inserire alcune informazioni nel nostro intento
e vogliamo avere un nome utente.
Le citazioni non sono obbligatorie, credo, ma io continuo a farlo, quindi non chiedetemi nulla.
Ok.
Questa è la nostra chiave.
E ora diciamo, per esempio, di fare un test, ok, mettiamo questo smartphone a destra e facciamolo
ancora una volta.
Bello.
Ora possiamo vedere che l'applicazione si è comportata in modo diverso.
Quindi ha reagito al nostro intento con le nostre informazioni aggiuntive.
Il test viene stampato qui.
Cioè, non stiamo avendo una sorta di punti di interazione.
Quindi non è possibile inserire cose come queste che riflettono il cross-site scripting perché questo non è
in quel browser.
Ma sì, potremmo usarlo per qualche tipo di phishing.
Ad esempio, la vostra password è stata violata.
Per favore, cambiatelo qui.
Quindi l'utente potrebbe trovare una nuova password.
Ma non ne ricaviamo un vantaggio perché l'utente sta solo definendo una nuova password per la propria
applicazione.
Tuttavia, questo è il modo in cui si può interagire con l'applicazione nel caso in cui si abbiano
più intenti o valori non intensi nel nostro intento.
Vediamo.
Sì.
Se ne avete uno in più, fatelo.
Facciamolo.
Forse in questo modo.
PIN, allora
possiamo semplicemente metterli insieme.
Quindi qui stiamo avendo questo nome utente.
Permettetemi di chiudere il discorso sullo sfondo.
Questi sono i processi.
Ok, è vicinanza.
Ok, quindi ora...
Possiamo leggerlo un po' più facilmente.
Ecco quindi il test del nome utente.
E poi potremmo anche fare questo, ad esempio.
Ok.
Ecco come possiamo applicare più stringhe ai nostri valori, ai nostri intenti.
Nel caso in cui si disponga di un numero intero, occorre utilizzarlo nel modo seguente.
Va bene.
Ok.
Quindi sì, se si forniscono intenti aggiuntivi a cui l'applicazione non reagisce perché non sono
tutti originariamente inclusi, vengono semplicemente ignorati.
Ok.
Ora vediamo se possiamo cambiare il perno qui.
Quindi abbiamo questo test e diamo un
nome al.
E ora, vediamo, abbiamo definito un nuovo pin, che è uno quattro, sette, otto, nove invii.
PIN in alto.
Hanno avuto successo.
Ok.
Sembra buono.
Chiudiamo questa applicazione.
E riapriamola.
Intendo dire che il nome utente è ancora admin.
Non è stato violato, ma vediamo se abbiamo sovrascritto il pin di questo utente.
14789.
Sì.
Bello.
Quindi abbiamo sovrascritto il pin di questo utente perché c'è un solo pin disponibile.
Pertanto il nome dell'utente non ha più importanza.
È semplicemente necessario.
E se non lo è, allora non funzionerà.
Ma se possiamo applicare qualsiasi valore dell'utente, stiamo sovrascrivendo il pin.
Va bene.
Ok.
Incredibile.
A destra.
Diamo quindi una rapida occhiata a questo file.
Quindi all'interno della shell ADB privilegi di root e poi all'interno dei dati.
L'allarme di hacking dell'app Com per lo sniffing intenso dei pin è un aspetto che esamineremo tra poco.
Quindi non preoccupatevi.
Anche ora, avendo queste preferenze condivise, A. B che ha il nostro esempio di PIN ed eccolo qui.
Sì, possiamo vedere che abbiamo sovrascritto il pin.
Va bene.
È questa la capacità del simbolo di reagire alle attività in questa applicazione.
Non è che non si verifichi più spesso.
Può ancora essere possibile, ma non accade spesso.
Per quanto riguarda i ricevitori broadcast, il discorso è diverso.
Quindi, all'interno di un ricevitore broadcast, questo può ancora accadere abbastanza spesso.
Si tratta di un aspetto che dovreste assolutamente verificare e di cui parleremo diffusamente nell'argomento
relativo ai ricevitori broadcast.
Va bene.
Ok.
Un ultimo esempio relativo agli intenti impliciti, perché trovo piuttosto ridicolo inviare un intento senza
sapere quale applicazione reagisce a questo.
E supponiamo di avere più applicazioni.
Che cosa succede poi stanno aprendo tutti o come è stato gestito?
Questo è un aspetto che esamineremo subito.
E successivamente, in un nuovo video, si parla di intent sniffing.
Pertanto, non abbiamo ancora finito.
Ok, allora chiudiamo il discorso.
Va bene.
Abbiamo già visto questo intento implicito.
Quindi, nell'esempio del manifest di Android, abbiamo inviato questo intent e fortunatamente c'era solo un'applicazione che è stata registrata
a questo intent, perché non si tratta di un intent personalizzato.
Ma cosa succede se si invia un intento a cui sono state registrate molte applicazioni
e scopriamolo.
Possiamo quindi procedere come segue.
Ok, quindi stiamo usando ancora una volta il nostro gestore di attività e ora stiamo inviando
un intent che viene usato da molte applicazioni, che potrebbe essere, ad esempio, un intent view di Android.
Quindi questa è un'azione comune per un intento e possiamo anche applicare una categoria, questa qui.
Sono quindi molte le domande che sono state registrate a questo evento.
Quindi mettiamo tutto o tutti gli smartphone nella scatola.
Mettiamo lo smartphone in primo piano e vediamo cosa succede se lo attiviamo.
Lo eseguo in 3 contro 1.
E.
Interessante.
Qui possiamo vedere che abbiamo un'applicazione, lo sniffing intenso, che potrebbe essere stata usata in precedenza,
ma anche tutte le altre applicazioni sono state registrate a questo evento.
Quindi queste sono tutte applicazioni che sono state registrate e tutte dicono allo smartphone: "Ehi,
la tua richiesta, posso gestirla" e l'utente non ha la possibilità di scegliere se aprire l'applicazione.
È quindi l'utente a decidere quale evento deve reagire.
Ad esempio, questo calendario, l'applicazione Calendario verrà aperta o reagirà a questo evento, mentre tutti gli altri verranno
semplicemente ignorati.
Ok.
Questo è il concetto che sta alla base di un intento implicito che invia un evento senza sapere quale applicazione
si aprirà.
L'altro è l'intento esplicito.
E questo è qualcosa che abbiamo visto qui.
Quindi vediamo questo.
Si definisce quindi il nome esatto del pacchetto che deve servire questo evento.
E questo è qualcosa che non possiamo annusare.
Quindi, se stiamo chiamando un intento esplicito, se diciamo a questa applicazione, a questa modifica dell'attività di aprirla,
possiamo, ovviamente, fornire anche alcuni dati.
Ma questa è un'informazione che non può essere sniffata da un'altra applicazione per quanto riguarda gli intenti impliciti
come questo.
Questa è una storia diversa.
Quindi, se l'utente non fa clic, l'aggressore avrà le informazioni.
Va bene.
Ok.
Se avete domande su questo argomento, lasciatemi un messaggio nella sezione dei commenti
o altro.
Non vedo l'ora di vederti nella prossima parte.