Verifica dell'applicazione - Test delle applicazioni

Articolo
06/14/2023

Application Verifier (AppVerifier) è uno strumento di verifica di runtime per il codice non gestito che consente di trovare errori di programmazione sottili, problemi di sicurezza e problemi limitati relativi ai privilegi dell'account utente che possono essere difficili da identificare con le normali tecniche di test delle applicazioni.

Per distribuire applicazioni Windows affidabili:

Testare le applicazioni scritte in codice non gestito (nativo) con Application Verifier nel debugger e con heap a pagina intera prima di rilasciarla ai clienti.
Seguire i passaggi forniti da Application Verifier per risolvere le condizioni erranti.
Dopo il rilascio dell'applicazione, monitorare regolarmente i report sugli errori dell'applicazione raccolti, ad esempio da Segnalazione errori Windows, se disponibile.

I controlli del pool di thread sono abilitati per impostazione predefinita nell'intestazione di controllo "Informazioni di base". Poiché questa impostazione è inclusa nell'impostazione predefinita, gli utenti devono solo eseguire Application Verifier nel codice con le impostazioni predefinite per sfruttare questi e altri controlli importanti.

Configurazione di Application Verifier

Configurazione del debugger

L'applicazione verificata deve essere eseguita in un debugger in modalità utente o il sistema deve essere eseguito in un debugger del kernel perché si interromperà in un debugger quando si verifica un errore. Per altri dettagli sul debugger, vedere Application Verifier - Debugging Application Verifier Stops (Verifica applicazione - Debug delle interruzioni dell'applicazione ).

Impostazioni

Impossibile abilitare Application Verifier per un processo in esecuzione. Di conseguenza, è necessario impostare le impostazioni come descritto di seguito e quindi avviare l'applicazione. Le impostazioni sono persistenti fino a quando non vengono eliminate in modo esplicito. Pertanto, indipendentemente dal numero di volte in cui si avvia un'applicazione, verrà avviata con AppVerifier abilitato fino a quando le impostazioni non vengono eliminate.

Uso del test di base di Application Verifier

Gli scenari seguenti illustrano le opzioni consigliate della riga di comando e dell'interfaccia utente. Queste operazioni devono essere eseguite durante tutti i test che eseguono l'esercizio del codice per garantire la copertura completa. L'aspettativa per questi scenari è che l'applicazione non si interrompe nel debugger e tutti i test passano con la stessa frequenza di superamento di quando viene eseguito senza AppVerifier abilitato.

Abilitare la verifica per le applicazioni che si desidera testare usando. Dalla riga di comando: appverif /verify MyApp.exe.

Dall'interfaccia utente: aggiungere l'applicazione facendo clic con il pulsante destro del mouse nell'area Applicazioni e selezionando Aggiungi applicazione. Selezionare Le nozioni di base nell'area Test. Fare clic su Salva.

Note:

/verify abiliterà i test di base

Se si sta testando una DLL, Application Verifier deve essere abilitato per l'eseguibile di test che sta esercitando la DLL.

Eseguire separatamente i livelli di verifica. Ad esempio, in una sessione abilitare tutte le informazioni di base e in un'altra abilitare tutti i controlli LuaPriv.

Eseguire TUTTI i test che eseguono l'applicazione.

Analizzare eventuali interruzioni del debugger rilevate. Se si verifica un'interruzione, sarà necessario comprenderla e correggerla. NOTA: il contenuto della Guida fornisce informazioni dettagliate sulle interruzioni e su come esaminarle.

Al termine, eliminare tutte le impostazioni. Dalla riga di comando: appverif /n MyApp.exe.

Dall'interfaccia utente rimuovere l'applicazione facendo clic con il pulsante destro del mouse nell'area Applicazioni e selezionando Elimina applicazione. Fare quindi clic sul pulsante Salva.

Danneggiamento dell'heap

Quasi il 10% degli arresti anomali delle applicazioni nei sistemi Windows è dovuto al danneggiamento dell'heap. Questi arresti anomali sono quasi impossibile eseguire il debug dopo il fatto. Il modo migliore per evitare questi problemi consiste nel testare le funzionalità dell'heap di pagina disponibili in Application Verifier. Esistono due tipi di Heap pagina: "Full" e "Light". Full è il valore predefinito; forza l'arresto immediato di un debugger al rilevamento del danneggiamento. Questa funzionalità DEVE essere eseguita durante il debugger. Tuttavia, è anche la risorsa più impegnativa. Se un utente presenta problemi di temporizzazione e ha già eseguito uno scenario in Heap pagina "Completo", impostandolo su "Light" probabilmente risolverà questi problemi. Inoltre, l'heap pagina leggera non si arresta in modo anomalo fino a quando il processo non viene chiuso. Fornisce un'analisi dello stack all'allocazione, ma può richiedere molto più tempo per la diagnosi rispetto all'uso della controparte Completa.

Uso di AppVerifier Low Resource Simulation (inserimento di errori)

L'aspettativa per questo scenario è che l'applicazione non si interrompe nel debugger. Non suddividendo il debugger significa che non sono presenti errori che devono essere risolti.

La frequenza di superamento per i test può diminuire in modo significativo perché le iniezioni di errore casuali vengono introdotte nel normale funzionamento.

Abilitare Application Verifier Low Resource Simulation (fault injection) per le applicazioni. Dalla riga di comando: Appverif /verify MyApp.exe /faults. Dall'interfaccia utente: aggiungere l'applicazione facendo clic con il pulsante destro del mouse nell'area Applicazioni e selezionando Aggiungi applicazione . Selezionare La simulazione risorse bassa nell'area Test. Fare clic su Salva.

Nota: se si esegue il test di una DLL, è possibile applicare una simulazione di risorse bassa (inserimento di errori) in una determinata DLL invece dell'intero processo. Il formato della riga di comando sarà:

appverif /verify TARGET [/faults [PROBABILITY [TIMEOUT [DLL …]]]]

Esempio:

appverif /verify mytest.exe /faults 50000 1000 d3d9.dll

Eseguire TUTTI i test che esercitano l'applicazione

Analizzare eventuali interruzioni del debugger rilevate. Se si verifica un'interruzione, sarà necessario comprenderla e correggerla.

Al termine, eliminare tutte le impostazioni. Dalla riga di comando: appverif /n MyApp.exe. Dall'interfaccia utente: rimuovere l'applicazione facendo clic con il pulsante destro del mouse nell'area Applicazioni e selezionando Elimina applicazione, facendo clic sul pulsante Salva.

Nota: l'esecuzione con e senza esercizi di inserimento degli errori è in gran parte diversi percorsi di codice in un'applicazione e pertanto entrambi gli scenari devono essere eseguiti per ottenere il massimo vantaggio di AppVerifier.

Uso di Application Verifier con WOW64

È possibile usare la versione a 32 bit o a 64 bit di Application Verifier per verificare un'applicazione a 32 bit in esecuzione in WOW64.

Analisi dei dati di AppVerifier

Tutti i dati creati durante l'analisi di AppVerifier vengono archiviati nella cartella %USERPROFILE%\AppVerifierLogs in un formato binario. Questi log possono quindi essere convertiti in XML tramite l'interfaccia utente o la riga di comando per un'ulteriore analisi.

Per visualizzare i file XML, è possibile utilizzare qualsiasi strumento per visualizzare il codice XML, ad esempio l'importazione in Microsoft Excel - Importare il file XML in Excel e usare filtri o tabelle pivot per riorganizzare e analizzare i dati raccolti.

Utilizzando la riga di comando

Application Verifier può essere usato tramite l'interfaccia utente o usando le opzioni della riga di comando.

Di seguito sono riportati esempi di come usare la riga di comando (di seguito sono riportati i dettagli):

appverif /verify TARGET [/faults [PROBABILITY [TIMEOUT [DLL …]]]]

appverif /verify notepad

appverif -enable LAYER … -for TARGET ... [-with [LAYER].PROPERTY=[VALUE] …] 

appverif -disable LAYER ... -for TARGET ...

appverif -query LAYER ... -for TARGET ...

appverif –configure STOP ... -for TARGET ... [-with STOPPROPERTY=[VALUE] …]

appverif –logtofile {enable|disable}

Per abilitare Application Verifier per un livello di verifica specifico per due applicazioni:

appverif –enable Heaps Locks –for notepad.exe iexplore.exe

Per abilitare due livelli denominati X e Y per test.exe di destinazione con proprietà X.DebugLevel e Y.DebugLevel:

appverif –enable X Y –for test.exe –with X.DebugLevel=1 Y.DebugLevel=2

Per disabilitare tutti i controlli eseguiti in un'applicazione:

appverif -disable * -for notepad.exe

appverif -delete settings -for notepad.exe

Per abilitare o disabilitare la registrazione di Application Verifier a livello globale per tutti i processi:

appverif –logtofile enable

appverif –logtofile disable

La registrazione è abilitata per impostazione predefinita per tutti i processi.

Sintassi della riga di comando di Application Verifier

Utilizzo della riga di comando di Application Verifier:

-enable TEST ... -for TARGET ... [-with [TEST.]PROPERTY=VALUE ...]
-disable TEST ... -for TARGET ...
-query TEST ... -for TARGET ...
-configure STOP ... -for TARGET ... -with PROPERTY=VALUE...
-verify TARGET [-faults [PROBABILITY [TIMEOUT [DLL ...]]]]
-export log -for TARGET -with To=XML_FILE [Symbols=SYMBOL_PATH] [StampFrom=LOG_STAMP] [StampTo=LOG_STAMP] [Log=RELATIVE_TO_LAST_INDEX]
-delete {logs|settings} -for TARGET ...
-stamp log -for TARGET -with Stamp=LOG_STAMP [Log=RELATIVE_TO_LAST_INDEX]
-logtoxml LOGFILE XMLFILE
-installprovider PROVIDERBINARY
-sppath [PROTECTED_PROCESS_LOG_PATH]
-cppath
-logtofile [enable | disable]

La sintassi della riga di comando accetta uno o più livelli e li applica a una o più destinazioni con identificatori di proprietà facoltativi per i livelli.

appverif -enable LAYER ... -for TARGET ... [-with [LAYER].PROPERTY=[VALUE] …] appverif -disable LAYER ... -for TARGET ... appverif -query LAYER ... -for TARGET ... appverif –configure STOP ... -for TARGET ... [-with STOPPROPERTY=[VALUE] …]

dove:

LAYER è un nome standard per un livello di verifica. Se viene installato un nuovo provider di verifica, verrà esposto un nuovo nome del livello di verifica da usare nella riga di comando. I livelli di esempio sono Heap, Handle o Blocchi.

È possibile impostare LAYER su * per specificare che il comando si applica a tutti i livelli.

TARGET è un nome binario (ad esempio, notepad.exe). Si tratta di un'impostazione statica persistente nel Registro di sistema e che verrà presa in considerazione ogni volta che l'applicazione viene avviata. Per il comando appverif –disable, è possibile impostare TARGET su * per specificare che tutte le destinazioni devono essere disabilitate.

PROPERTY è il nome della proprietà specifico del LIVELLO indicato nella riga di comando. Ad esempio, il livello Handle contiene tracce come proprietà.

VALUE è un valore per la proprietà. Il tipo del valore dipende dal tipo associato alla proprietà e verrà applicato. I tipi supportati per il momento sono: boolean (true/false), integer (decimal/octal/hex nella notazione C), stringa e multi-stringa (contenente \0’ between strings and being terminated by \0\0'). Se VALUE non viene specificato, significa che l'utente vuole eliminare tale proprietà e ripristinare il comportamento al valore predefinito per la proprietà.

STOP è il numero (decimale o esadecimale nella notazione C) del problema di arresto del verificatore da configurare. I codici di arresto devono essere univoci (non è possibile usare lo stesso codice di arresto, pertanto lo strumento stesso determinerà il livello a cui appartiene l'arresto)

STOPPROPERTY è un nome di proprietà accettabile per gli arresti del verificatore. Se il valore non viene specificato, si presuppone che la proprietà debba essere eliminata. Le proprietà consentite per le interruzioni sono (vedere Configurazione degli arresti di verifica sotto per altri dettagli):

ErrorReport
Gravità
Sapore

Le proprietà possono essere facoltativamente qualificate dal livello a cui appartengono. Tuttavia, questo non è necessario se la riga di comando abilita solo un livello. Ad esempio, per abilitare due livelli denominati X e Y per i test.exe di destinazione con proprietà X.DebugLevel e Y.DebugLevel il comando è:

appverif –enable X Y –for test.exe –with X.DebugLevel=1 Y.DebugLevel=2

Tuttavia, se il livello X è abilitato, è possibile usare un nome di proprietà non qualificato:

appverif –enable X –for test.exe –with DebugLevel=1

Il carattere separatore tra il nome della proprietà e il valore possono essere = (segno uguale) o : (punti).

Comandi vari

appverif –query providers

appverif –delete logs –for TARGET ...

appverif –delete settings –for TARGET ...

Eliminare completamente TARGET dal Registro di sistema.

appverif –stamp log –for Target –with Stamp=”LOG_STAMP”[Log= RELATIVE_TO_LAST_INDEX]

Questo comando stamperà il log con LOG_STAMP. Questo stamp è utile per identificare solo una sezione di un log come pertinente durante la visualizzazione del modulo XML del log.

appverif –export log –for TARGET –with To=XML_FILE[Symbols=SYMBOL_PATH][Stamp=LOG_STAMP][StampTo=LOG_STAMP][Log=RELATIVE_TO_LAST_INDEX]

Il comando precedente esportare un log binario in un file xml. La proprietà Stamp facoltativa viene usata per identificare quale parte del log deve essere esportata in XML. Se non specificato, l'intero log verrà convertito. La proprietà Log ha un valore intero negativo il più possibile e indica il file di log che deve essere convertito dall'ultimo (assunto se la proprietà non è presente). Ad esempio, avviare notepad.exe tre volte in una riga. Per accedere al primo log creato, specificare Log=-2 nella riga di comando.

Collegamenti per la riga di comando

Di seguito sono riportati i tasti di scelta rapida:

appverif /verify TARGET [/faults [PROBABILITY [TIMEOUT [DLL …]]]]

dove:

TARGET ha lo stesso significato descritto in precedenza.

PROBABILITÀ è la probabilità di inserire errori. Deve essere un valore nell'intervallo 0..1000000. Se non è specificato il valore predefinito è 5%.

TIMEOUT è l'intervallo di tempo in millisecondi durante l'avvio del processo quando l'inserimento degli errori non si verifica. Questa operazione viene eseguita per consentire all'avvio corretto del processo prima che si verifichino errori. Se non è specificato il valore è 500 msec.

DLL è il nome del modulo che viene caricato nel processo. In genere questo è il nome di una libreria dinamica (estensione .dll) ma può essere un modulo ActiveX (estensione .ocx) o un altro modulo caricabile.

Esempi:

appverif /verify notepad.exe /faults 100000 1000 msvcrt.dll

Abilitare l'inserimento di errori per notepad.exe (ogni volta che verrà avviato). Gli errori devono verificarsi con probabilità 10%, solo 1000 msec dopo l'avvio del processo e solo per le operazioni avviate da msvcrt.dll.

Abilitazione dei dettagli dell'inserimento degli errori

L'uso della riga di comando /faults consentirà l'inserimento degli errori solo per OLE_ALLOC e HEAP_ALLOC. È tuttavia possibile usare la riga di comando per configurare il tipo di inserimento degli errori che si desidera attivare. Ad esempio, se si vuole inserire l'errore in un registro o un'API file come 2%, usare la riga di comando:

appverif -enable lowres -for hello.exe -with registry=20000 file=20000

Un altro esempio:

appverif -query lowres -for hello.exe

Settings for hello.exe:
Test [lowres] enabled.

Include = *
Exclude =
TimeOut = 2000 (0x7D0)
WAIT = 0 (0x0)
HEAP_ALLOC = 20000 (0x4E20)
VIRTUAL_ALLOC = 0 (0x0)
REGISTRY = 20000 (0x4E20)
FILE = 20000 (0x4E20)
EVENT = 0 (0x0)
MAP_VIEW = 0 (0x0)
OLE_ALLOC = 20000 (0x4E20)
STACKS = false

Configurazione degli arresti del verificatore

Usando la riga di comando (o l'interfaccia utente) è possibile configurare i arresti del verificatore. Di seguito sono riportati esempi per sfruttare:

Appverif -configure STOP ... -for TARGET ... -with PROPERTY=VALUE ...

STOP è il codice di arresto, ad esempio 0x200 0x201

TARGET è il nome dell'applicazione, ad esempio foo.exe

PROPERTY può essere una delle proprietà "ErrorReport", "Gravità" e "Flavor"

Per ErrorReport , VALUE può essere la combinazione dei valori seguenti.

0x00000001 significa che l'arresto è attivo. (Se questo bit è zero, significa che l'arresto è disabilitato)

0x00000020 significa che l'arresto si interromperà nel debugger usando un punto di interruzione.

0x00000040 indica l'interruzione di arresto nel debugger generando un'eccezione di verifica.

0x00000080 significa che l'arresto verrà registrato nel file di log.

0x00000100 significa che la traccia dello stack per questo arresto verrà registrata nel file di log.

Per gravità , VALUE può essere uno dei seguenti.

0x00000003 stop informativo.

0x0000000F avviso.

0x0000003F errore.

Per Flavor , Value può essere la combinazione dei valori seguenti.

0x00000002 arresto non continuabile.

0x00000010 Questa interruzione verrà visualizzata una sola volta. Verrà ignorato l'ora seguente all'interno dell'esecuzione del test.

Ad esempio, disabilitare arresti 0x2700, 0x2701 per foo.exe

Appverif –configure 0x2700 0x2701 –for foo.exe –with ErrorReport=0

Configurare il codice di arresto 0x2700 come interruzione nel debugger (è disattivato per impostazione predefinita), salvare un log senza traccia dello stack e renderlo non continuabile

Appverif –configure 0x2700 –for foo.exe –with ErrorReport=0xA1 Flavor=0x2

Opzioni di arresto del verificatore - Impostazioni avanzate

Application Verifier include impostazioni avanzate, ad esempio Inactivate, che è possibile modificare per arresto del verificatore.

Opzioni di arresto del verificatore : le opzioni di arresto del verificatore vengono modificate in una finestra di dialogo che elenca le opzioni disponibili. Per accedere alle opzioni di arresto del verificatore:

Selezionare il nome di un test nel riquadro Test.
Nel menu Modifica selezionare Opzioni di arresto verifica o Fare clic con il pulsante destro del mouse sul test e selezionare Verifica opzioni arresta.

Opzioni di arresto del verificatore

È possibile modificare gli elementi seguenti per arresto del verificatore elencati facendo clic sul codice di arresto (si noti che una descrizione dell'arresto verrà visualizzata quando si fa clic).

Inattiva è una casella di controllo che, quando selezionata, disattiva il codice di arresto dell'esecuzione del verificatore.

Gravità determina come deve essere contrassegnato l'arresto del verificatore:

Ignora
Informazioni
Avviso
Errore

Segnalazione errori determina come si vuole che il verificatore specifico venga segnalato/registrato:

Log to File : una casella di controllo che, quando selezionata, eseguirà l'accesso al file designato.

Traccia dello stack di log: una casella di controllo che, quando selezionata, registra le tracce dello stack quando sono disponibili.

Nessuna interruzione: un'opzione non da interrompere nel debugger.

Eccezione: un'opzione senza interruzione e punto di interruzione

Punto di interruzione: un'opzione senza interruzione o eccezione.

Varie offre due opzioni

Arresta una sola volta: una casella di controllo che quando selezionata si arresterà solo in tale errore una volta durante il test di un'applicazione.

Non Continuable: una casella di controllo che quando selezionata non consente di continuare senza analizzare.