Application Verifier - Testing Applications
Application Verifier (AppVerifier) è uno strumento di verifica in fase di esecuzione per il codice non gestito che aiuta a trovare errori di programmazione sottili, problemi di sicurezza e problemi limitati relativi ai privilegi degli account utente che possono essere difficili da identificare con le normali tecniche di test delle applicazioni.
Per offrire 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 inquieti.
- Una volta rilasciata l'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 sotto l'intestazione di controllo "Informazioni di base". Poiché questa opzione è inclusa nell'impostazione predefinita, gli utenti devono eseguire Application Verifier solo 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 interrompe in un debugger quando si verifica un errore. Per altri dettagli sul debugger, vedere Application Verifier - Debugging Application Verifier Arresta.
Impostazioni
Non è possibile 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. Devono essere eseguiti durante tutti i test che esercitano il codice per garantire la copertura completa. L'aspettativa per questi scenari è che l'applicazione non si interrompe nel debugger e tutti i test vengono superati con la stessa frequenza di superamento di quando viene eseguito senza AppVerifier abilitato.
Abilitare il verificatore 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 i livelli di verifica separatamente. Ad esempio, in una sessione abilitare tutte le nozioni di base e su un'altra abilitare tutti i controlli LuaPriv.
Eseguire TUTTI i test che esercitano l'applicazione.
Analizzare eventuali interruzioni del debugger rilevate. Se si verifica un'interruzione, è 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 impossibili da eseguire dopo il debug. Il modo migliore per evitare questi problemi consiste nel testare le funzionalità heap della pagina disponibili in Application Verifier. Esistono due tipi di Heap pagina: "Full" e "Light". Full è il valore predefinito; forza l'arresto istantaneo di un debugger al rilevamento del danneggiamento. Questa funzionalità DEVE essere eseguita nel debugger. Tuttavia, è anche la più impegnativa risorsa. Se un utente presenta problemi di intervallo e ha già eseguito uno scenario nell'heap di pagina "Completo", impostandolo su "Light" probabilmente risolverà questi problemi. Inoltre, l'heap pagina leggera non si arresta in modo anomalo fino all'uscita del processo. Fornisce un'analisi dello stack all'allocazione, ma può richiedere molto più tempo per diagnosticare 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 significativamente perché le iniezioni di errore casuali vengono introdotte nel normale funzionamento.
Abilitare Application Verifier Low Resource Simulation (inserimento di errori) 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 di risorse basse 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, è 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 di 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 ulteriori analisi.
Per visualizzare i file XML, è possibile utilizzare qualsiasi strumento per visualizzare il codice XML, ad esempio importando in Microsoft Excel - Importare il file XML in Excel e utilizzare filtri o tabelle pivot per riorganizzare e analizzare i dati raccolti.
Uso della 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 i test.exe di destinazione con le 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
O
appverif -delete settings -for notepad.exe
Per abilitare o disabilitare globalmente la registrazione di Application Verifier 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, puoi impostare TARGET su * per specificare che tutte le destinazioni devono essere disabilitate.
PROPERTY è il nome della proprietà specifico di LAYER indicato nella riga di comando. Ad esempio, il livello Handle ha 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: booleano (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 sul 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 interruzione devono essere univoci (nessun livello può usare lo stesso codice di arresto, quindi lo strumento stesso determinerà a quale livello 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 Configuring Verifier Stops below per altri dettagli):
- ErrorReport
- Severità
- Sapore
Le proprietà possono essere qualificate facoltativamente dal livello a cui appartengono. Tuttavia, questa operazione non è necessaria se la riga di comando abilita un solo livello. Ad esempio, per abilitare due livelli denominati X e Y per 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 può essere = (segno di uguale) o : (due punti).
Comandi vari
appverif –query providers
appverif –delete logs –for TARGET ...
appverif –delete settings –for TARGET ...
Cancellare 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 quando si visualizza il log nel modulo XML.
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 esporta un log binario in un file xml. La proprietà stamp facoltativa viene utilizzata per identificare quale parte del log deve essere esportata in XML. Se non specificato, verrà convertito l'intero log. La proprietà Log ha un numero intero negativo il più possibile e indica il file di log che deve essere convertito a partire dall'ultimo (si presuppone che la proprietà non sia 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 compreso 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 l'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 si tratta del 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 di 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 da attivare. Ad esempio, se si vuole inserire un errore in un registro o un'API di 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 verifier
Usando la riga di comando (o l'interfaccia utente) è possibile configurare l'arresto del verificatore. Di seguito sono riportati alcuni esempi da sfruttare:
Appverif -configure STOP ... -for TARGET ... -with PROPERTY=VALUE ...
STOP è codice di arresto, ad esempio 0x200 0x201
TARGET è il nome dell'applicazione, ad esempio foo.exe
PROPERTY può essere uno dei valori di "ErrorReport", "Gravità" e "Flavor"
Per ErrorReport , VALUE può essere la combinazione dei valori seguenti.
0x00000001 indica che l'arresto è attivo. (Se questo bit è zero, significa che l'arresto è disabilitato)
0x00000020 indica che l'interruzione verrà interrotta nel debugger usando un punto di interruzione.
0x00000040 indica l'interruzione nel debugger generando un'eccezione di verifica.
0x00000080 indica che l'arresto verrà registrato nel file di log.
0x00000100 indica che l'analisi dello stack per questa interruzione verrà registrata nel file di log.
Per gravità , VALUE può essere uno dei seguenti.
0x00000003 arresto 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 arresta 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 ogni arresto del verificatore.
Opzioni di arresto di Access Verifier - 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 scegliere Opzioni di arresto verifica.
Opzioni di arresto del verificatore
È possibile modificare gli elementi seguenti per ogni arresto del verificatore elencato 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 l'esecuzione del codice di arresto del verificatore.
La gravità determina come contrassegnare l'arresto del verificatore:
- Ignora
- Informazione
- Avvertimento
- Errore
Segnalazione errori determina la modalità di segnalazione/registrazione del verificatore specifico:
Log to File : casella di controllo che, quando selezionata, eseguirà l'accesso al file designato.
Analisi dello stack di log: una casella di controllo che, quando selezionata, registra le tracce dello stack quando sono disponibili.
Nessuna interruzione: opzione che non deve essere interrotta nel debugger.
Eccezione: opzione senza interruzione e punto di interruzione
Punto di interruzione: opzione senza interruzioni o eccezioni.
Varie offre due opzioni
Arresta una sola volta: una casella di controllo che, se selezionata, si interromperà solo una volta durante il test di un'applicazione.
Non continuabile: una casella di controllo che, se selezionata, non consente di continuare senza analizzare.
Vedere anche
Application Verifier - Panoramica
Application Verifier - Funzionalità
Application Verifier - Test in Application Verifier
Application Verifier - Codici di arresto e definizioni