Bentornati.
Sono molto eccitato perché ora impareremo il somalo e lo faremo hackerando questa applicazione mobile,
l'applicazione di pagamento dello spazio, prima di creare piccoli pezzi di applicazioni Android che servono a un compito
speciale, per esempio, che ci aiuta a imparare quali sono i nostri registri, quali sono le definizioni dei
tipi, quali valori ci sono dentro, come appare il codice della funzione?
Quali sono questi parametri?
Valori e oggetti di ritorno.
È un po' troppo impegnativo se lo facciamo tutto in una volta, quindi lo faremo passo dopo passo,
creando le nostre applicazioni Android piuttosto semplici e basilari, di cui conosciamo
il codice sorgente, e poi capiremo come appare il codice degli smiley.
Non inizieremo con l'applicazione Hello World perché non ho mai capito il motivo
di un'applicazione Helloworld.
Nella maggior parte dei casi sono già presenti alcuni elementi.
Abbiamo una stringa composta da caratteri, che è un array.
Abbiamo una funzione chiamata parametri e cose del genere.
Iniziamo con un piccolo programma di base che consiste in un solo valore intero, responsabile della potenza
del giocatore.
Poi capiamo come sono fatte tutte le cose e il passo successivo.
Cerchiamo di regolare questo valore per aumentare o diminuire la potenza del giocatore.
Va bene, andiamo.
Passiamo alla nostra VM Ubuntu e creiamo la nostra prima applicazione Android.
Bene, eccoci qui con la nostra macchina virtuale Ubuntu.
Scriviamo la nostra prima applicazione Android.
Quindi andiamo negli strumenti, in Android Studio bin e poi abbiamo questo punto di studio come script H e lo eseguiamo
semplicemente finché non otteniamo il punto di ingresso di Android Studio.
Quindi non preoccupatevi, non dovete sapere nulla sullo sviluppo di applicazioni Android.
Non scriveremo animazioni fantasiose, layout e applicazioni complesse.
Stiamo semplicemente inserendo il nostro codice Java in questa applicazione e premendo il pulsante di compilazione.
Questo è tutto.
Ok, creiamo un nuovo progetto.
Qui.
Abbiamo la nostra prima finestra travolgente.
Cosa dobbiamo scegliere qui?
Utilizziamo l'attività vuota.
Sappiamo cos'è un'attività.
È semplicemente un contenuto dello schermo.
È possibile scegliere tra diversi contenuti dello schermo.
Ad esempio, se si desidera includere Google Maps o un'attività a schermo intero o cose del genere,
ma tutte le altre attività rendono il layout o il codice più complesso.
Pertanto, ci atteniamo all'attività MBTI.
Si può anche scegliere nessuna attività, ma in questo caso non si ottiene l'output grafico, per cui ci si attiene all'attività
vuota.
È possibile procedere in questo modo.
Ora dobbiamo dare un nome alla nostra applicazione e io ho dato un nome a questo smile.
Qui possiamo vedere il nome del pacchetto.
Verrà regolato automaticamente all'interno della lingua.
Noi dichiariamo a Java e non a Colon Chavez.
È molto più semplice gestire questo aspetto.
E questo è un SDK minimo importante.
Ciò significa che l'applicazione deve essere compatibile con le versioni precedenti.
Nel nostro caso, credo che la nostra macchina virtuale esegua Android 9 o 10, quindi avremmo scelto
almeno questo.
Nel mio caso, ho scelto di tornare a marshmallow android 6.
Si può anche andare più indietro.
Quindi, ad esempio, 4. Anche il 4 non è un problema o il 2. 3 non è incluso in questa sede.
Ma quattro o quattro stanno funzionando.
A proposito, se utilizzate il vostro dispositivo, assicuratevi di includere almeno la versione
del vostro dispositivo.
In caso contrario, l'applicazione potrebbe non funzionare su questo dispositivo.
Ok.
Poi abbiamo premuto il tasto "finish".
Ora si passa al layout principale e questo potrebbe richiedere un po' di tempo.
Lo si può osservare nella parte inferiore.
Ora è l'indicizzazione.
Dopo, c'è una grande costruzione e sì, torneremo quando tutto sarà finito.
Cosa abbiamo qui?
Ebbene, questa è la nostra famosissima applicazione Hello World, che è travolgente, complessa e di
cui non si capisce nulla.
E non siamo nemmeno obbligati a farlo.
Tuttavia, vi ho fatto una breve introduzione.
Abbiamo quindi la nostra attività principale e questa attività estende la classe activity.
Questo non ci interessa.
Poi c'è il metodo create, importante perché un'attività ha una sorta di ciclo di vita.
Quindi, se si mette l'applicazione in background, c'è questo metodo di pausa che viene chiamato e se si
riporta l'attività in primo piano, c'è questo metodo di ripresa chiamato in questo stack
di attività.
Nel nostro caso, abbiamo questo metodo su create e ciò significa che se l'applicazione sta per essere
creata, questo metodo sarà chiamato.
E questo è sicuramente il caso.
Se avviamo l'applicazione e questa attività appare sullo schermo, possiamo considerarla come la nostra funzione
principale.
Quindi non ci si deve preoccupare di questo aspetto per creare una sovrascrittura.
Lo vedremo più avanti, non in questo capitolo, ma nell'ambito dell'analisi del runtime, quando daremo un'occhiata
allo stack di attività.
Ma per ora diciamo che questa è la nostra funzione principale
e che non ci interessa questo, quest'altro e anche il parametro laggiù.
Abbiamo appena inserito il codice qui.
Se vogliamo eseguire questo codice, questo è tutto ciò che dobbiamo sapere.
A sinistra, abbiamo la struttura di questa applicazione, quindi abbiamo l'esempio del manifest di Android.
Ce n'è uno.
E se si dà un'occhiata a questo, possiamo vedere che non ci sono permessi.
Possiamo vedere la nostra attività, questa attività principale qui.
E possiamo vedere questo noto filtro di intento, che significa che questa è la nostra attività di lancio.
Questo è il punto di ingresso di questa applicazione.
Bene, allora abbiamo qui l'elenco delle risorse.
Anche questo ci è abbastanza familiare.
E qui, tra l'altro, c'è questa cartella dei valori che contiene, per esempio, i colori, che sono relativi
al tema che stiamo usando e questi valori vengono compilati in questo punto delle risorse.
RC Per concludere la parte relativa alla struttura di Android, non ci interessa nemmeno questo.
Ora possiamo costruire ed eseguire questa applicazione, perché si tratta di un'applicazione già finita.
Ora possiamo semplicemente premere il pulsante di compilazione e creare la nostra prima applicazione senza inserire
alcuna riga di codice, perché questo è il blueprint della nostra applicazione Android.
Per fare questo potremmo dire build, build, bundle, build APK e questo potrebbe richiedere un po' di tempo la prima
volta, perché poi tutte queste cose vengono compilate in questo.
APK E se apportiamo una modifica, il compilatore si affida a una cache e questo sarà molto più veloce nel mio
caso.
Ora ho qui la build apk generata con successo e se clicco su locate abbiamo la nostra prima
build qui.
Quindi abbiamo creato un APK senza fare nulla, il che è fantastico, giusto?
Ok.
Torniamo quindi al nostro approccio reale.
Vogliamo imparare il somalo e quindi dobbiamo farlo passo dopo passo.
E iniziamo con il nostro programma Helloworld, che è un valore intero.
Ok, lasciate che chiuda qui.
Va bene.
Ora entriamo in questa e creiamo una nuova classe.
Questo rende la fase successiva un po' più semplice.
Abbiamo dato a questa classe il nome, ad esempio, di giocatore e qui definiamo un nuovo valore.
Diciamo che ogni potenza è uguale a dieci.
Va bene.
È tutto ciò che facciamo.
Niente di più.
Adesso facciamo solo questo.
Colpiamo, costruiamo, realizziamo, progettiamo.
I grandi costruttori sono in funzione.
Sembra tutto a posto.
Ora costruiamo pacchetti, costruiamo una bicicletta.
È sempre possibile colpire, costruire e distribuire direttamente l'apk.
Non è necessario utilizzare prima il progetto Make.
Ok.
Ora andiamo in questa posizione e abbiamo il nostro APK.
Procediamo con l'approccio "smile".
Per ottenere queste classi smiley, dobbiamo decompilare l'applicazione e per farlo usiamo
lo strumento APK, quindi rimaniamo nella stessa directory, facciamo clic con il pulsante destro del mouse e apriamo un nuovo terminale, quindi diciamo strumento
APK e debug apk.
Questo è stato terminato.
Passiamo al retro vuoto e ora abbiamo la directory degli smiley.
Diamo ora un'occhiata a questo aspetto.
Più in dettaglio.
Abbiamo Android, Android, X e com.
Questi due sono relativi al sistema di creazione delle applicazioni Android.
Quindi, se si torna indietro, non possiamo vederli qui.
E non c'è nemmeno.
Ma questi vengono compilati in questa applicazione in base alle cose che stiamo
usando.
Ad esempio, qui estendiamo una classe e quindi abbiamo bisogno anche del codice di questa classe.
Non ci interessano.
Ci interessa solo il pacchetto.
Smile di selezione e poi la classe del giocatore.
Vediamo, abbiamo questa directory.
Com e questo non contiene alcun imballaggio in Google.
Quindi ci atteniamo all'impacchettamento di uno smile e ora abbiamo tutte queste classi di smile.
Vediamo se riusciamo a vedere la nostra classe di giocatori.
Ecco la nostra classe di giocatori.
Bello.
Apriamo questo file e diamo un'occhiata al nostro esercizio hello world smiley.
Ok.
È possibile scegliere tra l'editor di codice, ha aggiunto, o nel mio caso sto usando l'editor di codice.
Quindi possiamo semplicemente trascinare e rilasciare questo qui, credo.
Sì.
E non c'è un'evidenziazione a forma di smile, ma possiamo usare l'evidenziazione di Java che è sufficiente per ottenere un
po' di informazioni su questo.
Ok.
Prima di analizzare il codice degli smiley, lasciate che vi mostri alcuni trucchetti interessanti.
Quindi, se tornate alla directory, possiamo anche usare Shadi X shade scusatemi e forniamo questa app
di debug apk.
E se si va su comm a Hacking Smiley one player, troveremo il pulsante smiley sotto questo.
Se premiamo questo tasto, compiliamo direttamente il nostro codice in smiley, quindi non dobbiamo usare lo
strumento APK per decompilarlo, ma c'è una differenza.
Lasciate che vi mostri questo.
Mettiamoli fianco a fianco.
Quindi questo riguarda il compilatore e questi sono diversi e quindi otteniamo anche un output
bytecode diverso.
Entrambi lo sono, ovviamente.
In questo.
Per quanto riguarda la decompilazione, lo strumento APK utilizza un compilatore diverso da quello di, ad esempio, ADC, e quindi
si ottiene anche un bytecode diverso.
Entrambe le uscite sono ovviamente valide.
Nel mio caso, mi piace attenermi all'output dello strumento APK perché è un po' più facile da leggere.
La soluzione di questo unico registro significa che il compilatore ha indicato che abbiamo due registri
e li possiamo vedere qui.
Abbiamo V zero e anche P zero.
In questo caso dice che abbiamo solo un registro locale che è V zero e p zero è un parametro.
Quindi forniamo un parametro.
A questo punto, lo strumento K fa la differenza tra i registri locali e i registri dei parametri e, sul lato destro,
questi vengono abbinati all'intero registro dell'argomento.
All'inizio potrebbe essere un po' confuso.
Lo capisco perfettamente, ma volevo solo mostrarvi che si ottengono risultati diversi.
Se si utilizzano strumenti diversi, è consigliabile attenersi all'output dello strumento APK, perché è un po' più preciso
per quanto riguarda la denominazione di questi strumenti.
Ok, queste uscite sono diverse, ma il risultato è lo stesso.
Quindi entrambe le applicazioni funzionano nello stesso identico modo.
Infine, c'è anche un plugin per Android Studio, per cui non è necessario compilare l'applicazione
con Android Studio e decompilarla successivamente.
Con lo strumento APK, possiamo farlo direttamente con uno studio Android.
Per inserire questo plug in, andiamo nelle impostazioni dei file.
Plug-in e assicuratevi di aver selezionato il marketplace qui.
E poi cerchiamo Java in Somalia, questo.
E poi abbiamo installato.
Leggete attentamente i termini e le condizioni e, se li accettate, possiamo installarlo.
Fare clic.
Ok.
Ora il plugin è stato incluso in questo ID e possiamo utilizzarlo a volte.
È inoltre necessario riavviare Android studio affinché questo effetto abbia luogo.
Ok.
Facciamo clic sulla nostra classe giocatore qui e poi andiamo a costruire e alla fine abbiamo questo pulsante
compila a Smiley.
Colpiamo questo.
Ci vuole un po' di tempo.
Possiamo osservarlo nella parte inferiore di questa pagina e, una volta terminato, avremo un nuovo top qui.
Va bene.
Ed ecco che ora abbiamo il codice somalo decompilato, tutto di questa classe Java.
Possiamo vedere che utilizza anche questo approccio, come fa con la parte del registro.
Quindi non li dividiamo tra parametri e variabili locali.
Li riassumiamo e li inseriamo nel registro.
Nel mio caso, però, non mi piace molto questo approccio perché avere la possibilità di separare le variabili
locali e i parametri rende Mali ancora più semplice.
Pertanto, preferisco attenermi all'approccio dello strumento APK, ma se dovete svolgere un'attività veloce, questo
può essere molto utile.
Potete scrivere il vostro codice qui e poi premere questo pulsante per ottenere direttamente il
vostro codice smiley.
Bene, ora analizziamo il primo output della nostra applicazione Hello World.
Quindi questo output del Mali, che analizzeremo nelle diapositive.
Quindi prendo questo risultato, lo metto su una diapositiva e lo esamino.
Torniamo indietro e diamo un'occhiata a questo aspetto.
Ok.
Facciamo un breve riepilogo.
Abbiamo quindi la nostra applicazione.
Abbiamo inserito una nuova classe e abbiamo aggiunto la variabile power.
Abbiamo compilato la nostra domanda e questo è stato il nostro punto di partenza.
Dopo quello che abbiamo fatto, hanno compilato l'applicazione con lo strumento APK e alla fine abbiamo ottenuto
la struttura dello smiley.
La struttura smiley contiene singole directory e queste singole directory sono relative al pacchetto
del nome della classe.
Quindi, se li confrontiamo tra loro, possiamo vedere che il pacchetto com picking smiley ha esattamente lo stesso
nome di pacchetto.
Questa è la struttura del nostro smiley e quindi possiamo trovare immediatamente la classe player dot smiley.
Ok, questo è quello che abbiamo.
Ora analizziamo il nostro codice smiley.
A sinistra c'è lo smiley con il pallino del giocatore e a destra il giocatore o Java.
Il player dot Java si presentava così.
Abbiamo la nostra classe al potere, a sinistra abbiamo la parte smile decompilata.
Ora vediamo cosa possiamo capire in questo momento?
E sarò assolutamente onesto con voi: se c'è qualcosa che non capiamo, Mark, allora per favore
mandatemi un messaggio sotto questa casella.
Va bene?
Ok.
Cosa abbiamo qui?
Diamo un'occhiata.
Beh, ok.
Hmm.
No, è fantastico.
Già.
Ok, ho capito.
Riesci a riconoscere questo?
Riuscite a individuare il valore dieci, magari sul lato sinistro.
Ma forse se ci concentriamo fortemente sul lettore o sul file Java, forse riusciamo a identificare il valore
dieci sul lato sinistro.
Vi lascio quindi un momento per riflettere su questo.
Vediamo il valore di rotazione.
Hmm.
Non è assolutamente presente nel valore decimale.
Pensiamo a ciò che abbiamo sul lato sinistro.
Abbiamo una serie di parole molto strane.
Non lo capiamo, ma abbiamo una x zero, una e una x zero.
Questo potrebbe essere un esagono.
Non lo so.
Vediamo se stiamo usando una shell python.
Possiamo rappresentare questo valore dieci sotto forma di valore esadecimale.
Quindi apriamo un nuovo terminale python e digitiamo x dieci e otteniamo questo 0xa e lo 0xa è anche sul lato
sinistro.
Quindi questo potrebbe essere il nostro valore.
Ten Al momento non lo sappiamo, ma è molto probabile che sia così.
Va bene.
Bello.
Abbiamo capito la nostra prima parte con uno smiley.
Ok.
Si tratta quindi di un passo enorme.
E avendo questo passo, possiamo anche fare molte cose in questo momento, anche se non capiamo
tutto il resto.
Lo vedrete tra poco, quando faremo il nostro primo esercizio.
Ma per il momento vorrei terminare questo video perché non voglio stare tanto insieme a
questo.
Abbiamo analizzato diversi approcci per ottenere il codice smiley da questa applicazione.
Abbiamo visto alcune tecniche molto veloci.
Ad esempio, Che scusa, il tasto smiley.
Inoltre, se vogliamo scrivere il nostro codice smiley, possiamo farlo direttamente in Android Studio.
Scriviamo il nostro codice Java e poi utilizziamo il plugin Java to Smiley.
Abbiamo anche analizzato le differenze del compilatore per quanto riguarda l'output degli smiley.
Perciò abbiamo visto che alcuni compilatori riassumono questi registri in un unico grande blocco, mentre altri li
dividono tra parametri e variabili locali.
Poi abbiamo analizzato il nostro primo codice smiley e ci siamo resi conto che non possiamo capirci nulla,
ma potremmo aver trovato il valore intero rappresentato nel codice smiley e questo è un affare enorme.
Ok.
E questo è anche il punto.
Ci fermiamo subito.
Lo facciamo passo dopo passo e per ora aumentiamo sempre di più i nostri stebbing.
Questo è tutto.
Non vedo l'ora di vederti nel prossimo video.