WEBVTT

00:00.870 --> 00:02.220
Ciao e bentornato.

00:02.310 --> 00:03.540
Continuiamo.

00:04.470 --> 00:09.840
Se facciamo clic su una di queste sezioni, possiamo vedere i dati qui sotto.

00:10.800 --> 00:13.020
Per la sezione dei dati, si può vedere la stringa.

00:13.020 --> 00:14.280
Salve, salve, mondo.

00:15.510 --> 00:28.020
Windows leggerà i dati nelle sezioni qui presenti dal file del disco e quindi utilizzerà il suo indirizzo grezzo, l'indirizzo grezzo

00:28.020 --> 00:34.470
e la dimensione grezza per copiarli nella memoria virtuale.

00:35.520 --> 00:41.760
Tuttavia, quando copia tutto questo nella memoria virtuale, utilizza la dimensione virtuale.

00:42.700 --> 00:48.010
La dimensione grezza e quella virtuale non sono uguali, come si può vedere.

00:49.150 --> 00:53.770
Pertanto, quando viene copiato nella memoria virtuale, si noterà che è diverso.

00:55.880 --> 01:01.100
Possiamo confermarlo verificando con Process Hacker qui.

01:01.130 --> 01:10.040
L'indirizzo grezzo è 200, ma quando viene copiato nella memoria virtuale, assumerà un indirizzo diverso

01:10.640 --> 01:12.830
e l'offset sarà 1000.

01:12.830 --> 01:19.040
Quindi, quando veniamo qui, possiamo vedere che l'offset è 1000.

01:20.750 --> 01:24.500
400000 è l'indirizzo dell'immagine di base, come abbiamo visto in precedenza.

01:24.650 --> 01:29.660
Quindi prendiamo la base dell'immagine più l'offset e otteniamo questo indirizzo.

01:30.440 --> 01:33.980
Successivamente, esamineremo i file DLL.

01:34.250 --> 01:36.020
Librerie a collegamento dinamico.

01:37.320 --> 01:39.860
Consideriamo un programma.

01:40.770 --> 01:41.670
Come questo.

01:42.720 --> 01:45.660
Ora c'è il programma uno e il programma due.

01:46.140 --> 01:48.510
Entrambi fanno uso della funzione helper.

01:49.260 --> 01:57.270
Dal momento che entrambi condividono lo stesso codice, sarebbe meglio creare un file dalla funzione helper in

01:57.270 --> 02:02.070
modo che possano condividere il codice piuttosto che ripetere la funzione

02:02.250 --> 02:04.530
helper in ogni codice.

02:06.240 --> 02:13.560
Quindi, se si toglie la funzione helper e la si inserisce in un file, si otterrà qualcosa di molto diverso.

02:13.590 --> 02:14.550
Diamo un'occhiata.

02:15.150 --> 02:17.080
Alla fine otterremo qualcosa di simile.

02:17.160 --> 02:23.760
Ora questa funzione ausiliaria è stata inserita in un file DLL.

02:24.180 --> 02:28.260
Questo è il significato delle librerie di collegamento dinamico DLL.

02:28.800 --> 02:32.580
Ha le caratteristiche di . estensione del dll sul retro.

02:33.150 --> 02:37.920
Anche un file DLL utilizza il formato PE.

02:39.730 --> 02:47.080
Proprio come il file eseguibile di Windows con l'estensione . estensione exe simile a quella dei

02:47.110 --> 02:48.250
file EXE.

02:49.240 --> 02:54.700
I file DLL contengono anche codice e istruzioni eseguibili.

02:55.450 --> 02:57.250
Se si fa clic su un file

02:57.430 --> 02:58.300
EXE.

02:59.380 --> 03:01.000
Verrà avviato come processo.

03:01.270 --> 03:07.390
Ma se si fa clic su un file DLL, non viene avviato un processo.

03:07.870 --> 03:18.730
Questo perché i file DLL non possono essere utilizzati indipendentemente e possono essere utilizzati solo in combinazione con

03:19.180 --> 03:20.770
un altro file EXE.

03:22.160 --> 03:30.230
È possibile utilizzare TrID per rilevare se un file è una DLL o un file EXE.

03:31.370 --> 03:36.680
Un altro modo è quello di utilizzare il campo delle caratteristiche nel formato del file PE.

03:37.790 --> 03:46.400
Se il file è una DLL, il campo delle caratteristiche contiene un valore che indica questa proprietà e CFF Explorer

03:46.400 --> 03:47.450
lo mostra.

03:49.310 --> 03:50.540
Facciamo un esempio.

03:52.790 --> 03:54.230
Campione 4-2.

03:56.970 --> 04:01.260
Eseguiamo TrID e controlliamo il campione 4-2.

04:04.010 --> 04:09.140
E si possono vedere 10. Il 3% dice che si tratta di una libreria di collegamento dinamico.

04:09.940 --> 04:15.610
Per confermarlo, possiamo aprirlo in CFF Explorer.

04:17.110 --> 04:21.760
Trascinatela qui e si aprirà una scheda separata per essa.

04:25.540 --> 04:33.610
Se si fa clic su Intestazione file e sul campo Caratteristiche, si può notare che il flag indica che il

04:33.640 --> 04:34.930
file è una DLL.

04:35.950 --> 04:43.570
Quindi il CFF Explorer e il TrID confermano che si tratta effettivamente di un file DLL.

04:45.520 --> 04:48.190
Una DLL è solo un altro file PE.

04:49.000 --> 05:00.010
Pertanto, quando un file PE eseguibile sta per essere eseguito, Windows carica prima i file DLL in memoria.

05:00.610 --> 05:07.810
Windows controllerà quindi l'elenco delle funzioni esportate dai file DLL.

05:09.160 --> 05:14.320
Facendo riferimento alla directory di importazione, nota anche come tabella di importazione.

05:14.800 --> 05:25.690
Quindi, se si torna all'esempio 4-1 e si fa clic su Importa directory, si può vedere che l'esempio 4-1

05:25.690 --> 05:30.460
deve avere msvcrt. dll.

05:31.540 --> 05:33.610
Quindi se ora si esegue.

05:42.410 --> 05:49.010
Esempio 4-1 e guardate la scheda Moduli.

05:58.430 --> 05:59.370
Apriamola.

05:59.990 --> 06:00.860
Hacker di processo.

06:15.330 --> 06:17.310
Fare doppio clic sul campione 4-1.

06:19.610 --> 06:24.920
Se si accede alla scheda Moduli, si vedrà che l'esempio 4-1 fa uso di.

06:27.170 --> 06:27.530
Questo.

06:29.250 --> 06:34.980
Ciò conferma quanto abbiamo appena visto con CFF Explorer.

06:36.920 --> 06:49.820
Ciò conferma che questa libreria, la libreria di runtime Microsoft C, viene caricata nella memoria virtuale del

06:50.180 --> 06:51.560
file EXE.

06:51.800 --> 06:53.660
Esempio 4-1.

06:54.530 --> 07:00.530
Una delle cose che si possono notare nella scheda Moduli è che ci sono

07:00.540 --> 07:03.410
molte altre DLL oltre a questa.

07:03.410 --> 07:05.600
Ma qui non si vede.

07:05.900 --> 07:09.800
Questo è dovuto al concatenamento delle dipendenze.

07:10.570 --> 07:17.890
Anche il file DLL del runtime di Microsoft Visual C ha delle dipendenze.

07:18.130 --> 07:20.410
Ha bisogno anche di altre DLL.

07:20.680 --> 07:25.570
Ecco perché sono presenti anche altre DLL.

07:26.420 --> 07:29.650
Oltre a questo msvcrt. dll.

07:30.950 --> 07:32.990
Quindi, insieme, formano una catena.

07:33.560 --> 07:36.370
Potrebbe essere necessario kernel32.

07:36.820 --> 07:38.570
kernel32 potrebbe aver bisogno di qualcos'altro.

07:38.570 --> 07:39.260
E così via.

07:39.620 --> 07:45.380
Si può anche usare Dependency Walker, che è qui per verificarlo.

07:46.460 --> 07:58.130
L'esempio 4-1 ha bisogno di questa DLL, ma questa DLL ne ha bisogno di molte altre come kernelbase, ntdll e così via.

07:58.460 --> 08:07.700
Ecco perché si vedono alcune DLL aggiuntive caricate nella memoria virtuale di questo EXE.

08:08.390 --> 08:11.840
Ecco cosa si intende per catena di dipendenze.

08:12.440 --> 08:20.060
Un altro concetto importante è quello di tabella degli indirizzi di importazione IAT.

08:20.360 --> 08:32.240
La domanda ora è: come fa il PE a sapere quale parte della DLL contiene la funzione di cui ha bisogno?

08:32.930 --> 08:38.300
Lo fa tramite una cosa nota come tabella degli indirizzi di importazione IAT.

08:39.470 --> 08:49.580
Tornando a questo esempio, il programma uno e il programma due devono entrambi utilizzare la funzione helper che proviene

08:49.580 --> 08:51.500
da questa DLL.

08:52.010 --> 08:54.800
Proviamo ora gli altri campioni.

08:57.140 --> 08:59.540
Rinominiamo il campione 4-2.

09:01.290 --> 09:08.070
E aggiungere . dll perché abbiamo appena confermato che si tratta di una DLL. Ora il campione 4-3

09:08.070 --> 09:16.800
è un EXE, quindi lo rinominiamo, e richiede la DLL di cui sopra.

09:21.460 --> 09:25.270
Chiudiamo la partita e facciamo un campione 4-3.

09:31.140 --> 09:39.860
Quindi, quando si esegue l'esempio 4-3, viene visualizzato il messaggio helper function 2 proveniente da questa DLL.

09:48.210 --> 09:52.910
Apriamo ora il campione 4-3 in CFF

09:52.920 --> 09:54.960
Explorer.

09:59.120 --> 10:00.080
E questo.

10:00.080 --> 10:03.230
Chiudiamo questo e lo carichiamo qui.

10:03.620 --> 10:09.530
Ora abbiamo due file, il campione 4-3 e il file DLL corrispondente.

10:11.790 --> 10:20.010
Se si osserva il campione 4-2. dll'Export Directory, si possono notare due funzioni che vengono esportate.

10:20.460 --> 10:28.710
E se andiamo a vedere il campione 4-3. exe Importa directory, vediamo che richiede il campione 4-2 e facciamo

10:29.280 --> 10:30.290
clic su di esso.

10:30.310 --> 10:39.720
Si può notare che richiede la funzione helper 2, che proviene dalla funzione helper 2 di Export Directory.

10:41.370 --> 10:44.480
Ecco come funzionano le DLL.

10:45.090 --> 10:54.930
La DLL ha una directory di esportazione che viene utilizzata dalla directory di importazione EXE.

10:57.840 --> 11:01.740
Questo è l'offset della funzione helper 2.

11:02.820 --> 11:03.420
Ok.

11:03.420 --> 11:06.480
È tutto per questa lezione.

11:06.510 --> 11:07.980
Grazie per aver guardato.
