ricerca difetti - Online nel cloud

PROGRAMMA:

NOME

faultfinder - trova lessicalmente potenziali falle di sicurezza ("hit") nel codice sorgente

SINOSSI

cercatore di difetti [--Aiuto|-h] [--versione] [--listruli]
[--allowlink] [--followdotdir] [--nessun collegamento]
[--patch=Nome del file|-P Nome del file]
[--input|-I] [ --livello minimo=X | -m X ] [--falso positivo|-F]
[--non ignorare|-n]
[--regex=MODELLO | -e MODELLO]
[--contesto|-c] [--colonne|-C] [--solo dati|-D] [--html|-H] [--immediato|-i]
[--linea singola|-S] [--Omittime] [--silenzioso|-Q]
[--loadhitlist=F] [--savehitlist=F] [--diffhitlist=F]
[--] [ source codice filetto or source radice elenco ]+

DESCRIZIONE

Flawfinder effettua ricerche nel codice sorgente C/C++ alla ricerca di potenziali falle di sicurezza. Per
eseguire faultfinder, fornire semplicemente a faultfinder un elenco di directory o file. Per ogni directory
dato, tutti i file che hanno estensioni di file C/C++ in quella directory (e i suoi
sottodirectory, ricorsivamente). Pertanto, per la maggior parte dei progetti, è sufficiente dare
faultfinder il nome della directory più in alto del codice sorgente (usa ``.'' per la corrente
directory) e faultfinder esaminerà tutto il codice sorgente C/C++ del progetto. Se tu
voglio solo avere i cambiamenti revisionato, salva una differenza unificata di tali modifiche (creata da GNU
"diff -u" o "svn diff" o "git diff") in un file di patch e utilizzare l'opzione --patch (-P).

Flawfinder produrrà un elenco di "risultati" (potenziali falle di sicurezza), ordinati per rischio; il
i colpi più rischiosi vengono mostrati per primi. Il livello di rischio è mostrato tra parentesi quadre e varia
da 0, molto poco rischio, a 5, grande rischio. Questo livello di rischio dipende non solo dal
funzione, ma sui valori dei parametri della funzione. Ad esempio, costante
le stringhe sono spesso meno rischiose delle stringhe completamente variabili in molti contesti, e in quelli
contesti il ​​colpo avrà un livello di rischio inferiore. Flawfinder conosce gettext (un comune
libreria per programmi internazionalizzati) e tratterà le stringhe costanti passate attraverso
gettext come se fossero stringhe costanti; questo riduce il numero di falsi colpi in
programmi internazionalizzati. Flawfinder farà la stessa cosa con _T() e
_TEXT(), macro comuni di Microsoft per la gestione di programmi internazionalizzati. Rilevatore di difetti
ignora correttamente la maggior parte del testo all'interno di commenti e stringhe. Normalmente il cercatore di difetti mostra tutto
colpi con un livello di rischio di almeno 1, ma puoi usare l'opzione --minlevel per mostrare solo
colpi con livelli di rischio più elevati, se lo desideri. Le descrizioni dei colpi notano anche il relativo Comune
Identificatori di enumerazione di debolezza (CWE) tra parentesi, come discusso di seguito. Rilevatore di difetti
è ufficialmente compatibile con CWE.

Non tutti i colpi sono in realtà una vulnerabilità della sicurezza, e non tutte le vulnerabilità della sicurezza
si trova necessariamente. Tuttavia, il rilevatore di difetti può essere un aiuto per trovare e rimuovere
vulnerabilità di sicurezza. Un modo comune per utilizzare il rilevatore di difetti è applicare prima il rilevatore di difetti a
un insieme di codice sorgente ed esaminare gli elementi a più alto rischio. Quindi, usa --inputs per esaminare
le posizioni di input e controllare per assicurarsi che solo i valori di input legali e sicuri siano
accettato da utenti non attendibili.

Dopo aver verificato un programma, puoi contrassegnare le righe del codice sorgente che in realtà sono corrette ma
causare avvisi spuri in modo che il rilevatore di difetti smetta di lamentarsene. Per contrassegnare un
riga in modo che questi avvisi vengano soppressi, inserisci un commento in formato speciale su
la stessa riga (dopo il codice sorgente) o da solo nella riga precedente. Il commento
deve avere uno dei due formati seguenti:

· // Flawfinder: ignora

· /* Rilevatore di difetti: ignora */

Per motivi di compatibilità, puoi sostituire "Flawfinder:" con "ITS4:" o "RATS:" in questi
commenti appositamente formattati. Poiché è possibile che tali linee siano sbagliate, puoi usare
l'opzione --neverignore, che fa sì che il rilevatore di difetti non ignori mai nessuna riga, qualunque cosa sia
dicono le direttive di commento (più confusamente, --neverignore ignora gli ignora).

Flawfinder usa un database interno chiamato ``ruleset''; il set di regole identifica
funzioni che sono cause comuni di falle di sicurezza. Il set di regole standard include un grande
numero di diversi potenziali problemi, inclusi entrambi i problemi generali che possono avere un impatto su qualsiasi
programma C/C++, oltre a una serie di funzioni specifiche di tipo Unix e Windows che sono
particolarmente problematico. L'opzione --listrules riporta l'elenco delle regole correnti e
loro livelli di rischio di default. Come notato sopra, ogni potenziale falla di sicurezza trovata in un dato
il file del codice sorgente (che corrisponde a una voce nel set di regole) è chiamato ``hit'' e l'insieme di
gli hit trovati durante una particolare esecuzione del programma sono chiamati ``hitlist''. Hitlist
può essere salvato (usando --savehitlist), ricaricato per la rivisualizzazione (usando --loadhitlist) e
puoi mostrare solo i risultati che sono diversi da un'altra esecuzione (usando --diffhitlist).

Flawfinder è uno strumento semplice, che porta ad alcuni pro e contro fondamentali. Il rilevatore di difetti funziona
eseguendo una semplice tokenizzazione lessicale (saltando i commenti e tokenizzando correttamente le stringhe),
ricerca di corrispondenze di token al database (in particolare per trovare chiamate di funzione).
Flawfinder è quindi simile a RATS e ITS4, che utilizzano anche una semplice tokenizzazione lessicale.
Flawfinder esamina quindi il testo dei parametri della funzione per stimare il rischio. a differenza di
strumenti come splint, i flag di avviso di gcc e clang, il rilevatore di difetti lo fa non usare o avere
accesso alle informazioni sul flusso di controllo, sul flusso di dati o sui tipi di dati durante la ricerca di
potenziali vulnerabilità o stimare il livello di rischio. Così, il cercatore di difetti lo farà
producono necessariamente molti falsi positivi per le vulnerabilità e non ne segnalano molti
vulnerabilità. D'altra parte, il rilevatore di difetti può trovare vulnerabilità nei programmi che
non può essere costruito o non può essere collegato. Può spesso funzionare con programmi che non possono nemmeno essere
compilato (almeno dagli strumenti del revisore). Anche Flawfinder non viene così confuso da
definizioni di macro e altre stranezze con cui gli strumenti più sofisticati hanno problemi.
Flawfinder può essere utile anche come semplice introduzione agli strumenti di analisi statica in
generale, poiché è facile da usare e facile da capire.

Qualsiasi nome di file fornito sulla riga di comando verrà esaminato (anche se non ha un solito
C/C++ estensione del nome del file); quindi puoi forzare il rilevatore di difetti ad esaminare qualsiasi file specifico che tu
desiderio. Durante la ricerca ricorsiva nelle directory, il rilevatore di difetti si apre ed esamina solo
file regolari con estensioni di file C/C++. Flawfinder presume che i file siano
File C/C++ se hanno le estensioni ".c", ".h", ".ec", ".ecp", ".pgc", ".C", ".cpp",
".CPP", ".cxx", ".cc", ".CC", ".pcc", ".hpp" o ".H". Il nome del file ``-'' significa il
ingresso standard. Per prevenire problemi di sicurezza, i file speciali (come i file speciali del dispositivo
e named pipe) vengono sempre saltati e per impostazione predefinita vengono saltati i collegamenti simbolici (il
L'opzione --allowlink segue i collegamenti simbolici).

Dopo l'elenco dei risultati c'è un breve riassunto dei risultati (usa -D per rimuoverlo
informazione). Mostrerà il numero di risultati, le linee analizzate (come riportato da wc -l) e
le linee di codice sorgente fisiche (SLOC) analizzate. Uno SLOC fisico è un non vuoto, non
riga di commento. Quindi mostrerà il numero di colpi a ogni livello; nota che ci sarà
non essere mai un successo a un livello inferiore a minlevel (1 per impostazione predefinita). Quindi, "[0] 0 [1] 9"
significa che al livello 0 ci sono stati 0 risultati segnalati e al livello 1 ci sono stati 9 risultati
segnalato. Successivamente mostrerà il numero di risultati a un dato livello o maggiore (quindi livello 3+
ha la somma del numero di colpi a livello 3, 4 e 5). Pertanto, una voce di "[0+] 37"
mostra che al livello 0 o superiore ci sono stati 37 risultati (la voce 0+ sarà sempre la stessa
come il numero "colpi" sopra). Successivamente vengono mostrati i risultati per KSLOC; questo è ciascuno dei "livello o
"più alto" moltiplicato per 1000 e diviso per lo SLOC fisico. Se i collegamenti simbolici fossero
saltato, ne viene riportato il conteggio. Se gli hit sono stati soppressi (usando l'opzione "ignora"
direttiva nei commenti del codice sorgente come descritto sopra), viene riportato il numero soppresso.
Viene visualizzato il livello di rischio minimo da includere nel report; per impostazione predefinita questo è 1
(usa --minlevel per cambiarlo). Il riepilogo termina con importanti promemoria: non tutti i risultati
è necessariamente una vulnerabilità di sicurezza e potrebbero esserci altre vulnerabilità di sicurezza
non segnalato dallo strumento.

Flawfinder è rilasciato sotto licenza GNU GPL versione 2 o successiva (GPLv2+).

Flawfinder funziona in modo simile a un altro programma, ITS4, che non è completamente open source
software (come definito nella Open Source Definition) né software libero (come definito dalla
Fondazione del Software Libero). L'autore di Flawfinder non ha mai visto il codice sorgente di ITS4.

BREVE TUTORIAL

Ecco un breve esempio di come potrebbe essere utilizzato il rilevatore di difetti. Immagina di avere il C/C++
codice sorgente per un programma chiamato xyzzy (che potresti aver scritto o meno), e
stai cercando vulnerabilità di sicurezza (così puoi risolverle prima dei clienti
incontrare le vulnerabilità). Per questo tutorial, presumo che tu stia usando un Unix-
come un sistema, come Linux, OpenBSD o MacOS X.

Se il codice sorgente si trova in una sottodirectory denominata xyzzy, probabilmente inizieresti aprendo a
finestra di testo e utilizzando le impostazioni predefinite di faultfinder, per analizzare il programma e riportare a
elenco prioritario di potenziali vulnerabilità di sicurezza (il ``meno'' si assicura solo che il
i risultati rimangono sullo schermo):
xyzzy | meno

A questo punto, vedrai un gran numero di voci. Ogni voce ha un nome di file, a
due punti, un numero di riga, un livello di rischio tra parentesi (dove 5 è il più rischioso), una categoria,
il nome della funzione e una descrizione del motivo per cui faultfinder pensa che la linea sia a
vulnerabilità. Flawfinder normalmente ordina per livello di rischio, mostrando prima gli elementi più rischiosi;
se hai poco tempo, probabilmente è meglio iniziare a lavorare sugli oggetti più rischiosi e
continua fino allo scadere del tempo. Se vuoi limitare la visualizzazione ai rischi con solo un
determinato livello di rischio o superiore, utilizzare l'opzione --minlevel. Se stai ricevendo un
numero straordinario di falsi positivi perché i nomi delle variabili sembrano pericolosi
nomi di funzioni, utilizzare l'opzione -F per rimuovere i report su di essi. Se non capisci
il messaggio di errore, vedere documenti come il scrittura Sicuro Programmi per Linux ed
Unix HOWTO ⟨http://www.dwheeler.com/secure-programs⟩ a http://www.dwheeler.com/secure-
programmi che fornisce maggiori informazioni sulla scrittura di programmi sicuri.

Una volta identificato il problema e capito, puoi risolverlo. A volte potresti
voglio rifare l'analisi, sia perché i numeri di riga cambieranno ed assicurarsi
che il nuovo codice non introduce ancora una vulnerabilità diversa.

Se hai stabilito che una linea non è davvero un problema e ne sei sicuro, puoi
inserisci subito prima o sulla riga incriminata un commento like
/* Rilevatore di difetti: ignora */
per evitare che vengano visualizzati nell'output.

Dopo averlo fatto, dovresti tornare indietro e cercare gli input del programma, per fare
assicurati che il programma filtri fortemente tutti i suoi input non attendibili. Flawfinder può
identificare molti input del programma utilizzando l'opzione --inputs, in questo modo:
ricerca difetti --input xyzzy

Flawfinder può integrarsi bene con editor di testo e ambienti di sviluppo integrati;
vedere gli esempi per maggiori informazioni.

Flawfinder include molte altre opzioni, incluse quelle per creare versioni HTML del
output (utile per display più belli). La prossima sezione descrive queste opzioni in altro
dettaglio.

VERSIONI

Flawfinder ha una serie di opzioni, che possono essere raggruppate in opzioni che ne controllano le proprie
documentazione, selezionare i dati di input, selezionare quali hit visualizzare, selezionare il formato di output,
ed eseguire la gestione delle hitlist. Flawfinder supporta la sintassi standard definita in
POSIX (Edizione 7, Edizione 2013) sezione ``Convenzioni di utilità''. Supporta anche GNU
opzioni lunghe (opzioni del modulo con doppio trattino --opzione) come definito nel GNU C Biblioteca
Riferimento Manuale ``Convenzioni sulla sintassi degli argomenti del programma'' e GNU codifica Internazionali
``Standard per le interfacce della riga di comando''. Argomenti di opzione lunghi possono essere forniti come
``--name=value'' o ``-name value''. È possibile accedere ad alcune opzioni solo utilizzando il di più
convenzioni leggibili per le opzioni lunghe di GNU; le opzioni comuni sono supportate anche dai più vecchi
convenzione di opzione a lettera singola.

Documentazione
--Aiuto

-h Mostra le informazioni sull'utilizzo (aiuto).

--versione Mostra (solo) il numero di versione ed esce.

--listruli Elencare i termini (token) che attivano un ulteriore esame, il loro rischio di default
livello e l'avviso predefinito (inclusi gli identificatori CWE), se
applicabile), tutte separate da tabulazioni. I termini sono principalmente nomi di potenzialmente-
funzioni pericolose. Si noti che il livello di rischio segnalato e l'avvertenza per alcuni
codice specifico può essere diverso da quello predefinito, a seconda di come è il termine
Usato. Combina con MrGreen se non vuoi la solita intestazione. Rilevatore di difetti
la versione 1.29 ha cambiato il separatore da spazi a tab e ha aggiunto il valore predefinito
campo di allerta.

Selezione Ingresso Dati
--allowlink Consentire l'uso di collegamenti simbolici; normalmente i collegamenti simbolici vengono saltati. non farlo
usa questa opzione se stai analizzando il codice da altri; gli attaccanti potrebbero farne molti
cose per causare problemi per un'analisi con questa opzione abilitata. Per
Ad esempio, un utente malintenzionato potrebbe inserire collegamenti simbolici a file come /etc/passwd
(perdendo informazioni sul file) o creare un ciclo circolare, che sarebbe
fa in modo che il rilevatore di difetti venga eseguito ``per sempre''. Un altro problema con l'abilitazione di questo
l'opzione è che se lo stesso file viene referenziato più volte usando simbolico
link, verrà analizzato più volte (e quindi riportato più volte).
Nota che il cercatore di difetti include già una protezione contro i collegamenti simbolici
a tipi di file speciali come i tipi di file di dispositivo (ad es. /dev/zero o
C:\mystuff\com1). Nota che per la versione 1.01 di Faultfinder e precedenti, questo era
il predefinito.

--followdotdir
Immettere le directory i cui nomi iniziano con ".". Normalmente tali directory sono
ignorati, poiché normalmente includono dati privati ​​di controllo della versione (come
.git/ o .svn/), configurazioni e così via.

--nessun collegamento Ignorato. Storicamente questo disabilitato seguendo i collegamenti simbolici; questo comportamento
è ora l'impostazione predefinita.

--patch=file di patch

-P file di patch
Esamina i file o le directory selezionati, ma riporta solo i risultati nelle righe che
vengono aggiunti o modificati dal file di patch specificato. Il file della patch deve essere in a
formato diff unificato riconosciuto (ad esempio, l'output di GNU "diff -u old new",
"svn diff" o "git diff [commit]"). Flawfinder presume che la patch abbia
già stato applicato ai file. Il file di patch può anche includere modifiche a
file irrilevanti (saranno semplicemente ignorati). I numeri di riga indicati in
patch sono usati per determinare quali linee sono state modificate, quindi se hai
modificato i file da quando è stato creato il file di patch, rigenerare il file di patch
primo. Attenzione che i nomi dei file dei nuovi file forniti nel file di patch
deve corrispondere esattamente, incluse maiuscole/minuscole, prefisso del percorso e directory
separatore (\ vs. /). Viene accettato solo il formato diff unificato (GNU diff, svn
diff e l'output di git diff va bene); se hai un formato diverso, di nuovo
rigenerarlo prima. Solo i risultati che si verificano sulle linee modificate risultanti, o
immediatamente sopra e sotto di essi, sono riportati. Questa opzione implica
--non ignorare.

Selezione Visualizzazioni a Dsiplay
--input

-I Mostra solo le funzioni che ottengono dati dall'esterno del programma; anche questo imposta
livello minimo a 0.

--livello minimo=X

-m X Imposta il livello di rischio minimo su X per l'inclusione nella lista dei risultati. Questo può essere da 0 (``no
rischio'') a 5 (``rischio massimo''); il valore predefinito è 1.

--falso positivo

-F Non includere risultati che potrebbero essere falsi positivi. Attualmente, questo significa
che i nomi delle funzioni vengono ignorati se non sono seguiti da "(", e che
le dichiarazioni degli array di caratteri non vengono annotate. Quindi, se usi una variabile
denominato "accesso" ovunque, questo eliminerà i riferimenti a questo ordinario
variabile. Questa non è l'impostazione predefinita, perché aumenta anche la probabilità di
perdere colpi importanti; in particolare, i nomi delle funzioni nelle clausole e nelle chiamate #define
tramite i puntatori di funzione verranno persi.

--non ignorare

-n Non ignorare mai i problemi di sicurezza, anche se hanno una direttiva ``ignore'' in a
commento.

--regexp=MODELLO

-e MODELLO
Segnala solo i risultati con testo che corrisponde al modello di espressione regolare PATTERN.
Ad esempio, per segnalare solo i risultati contenenti il ​​testo "CWE-120", utilizzare ``--regex
CWE-120''. Questi nomi di flag di opzione sono gli stessi di grep.

Selezione Uscita Formato
--colonne

-C Mostra il numero di colonna (così come il nome del file e il numero di riga) di ogni hit;
questo viene mostrato dopo il numero di riga aggiungendo i due punti e il numero di colonna in
la riga (il primo carattere in una riga è la colonna numero 1). Questo è utile
per editor che possono saltare a colonne specifiche o per l'integrazione con altre
strumenti (come quelli per filtrare ulteriormente i falsi positivi).

--contesto

-c Mostra il contesto, ad esempio la riga con il "colpo"/potenziale difetto. Per impostazione predefinita il
la riga viene visualizzata immediatamente dopo l'avviso.

--solo dati

-D Non visualizzare l'intestazione e il piè di pagina. Usalo insieme a --quiet per vedere solo
i dati stessi.

--html

-H Formatta l'output come HTML anziché come semplice testo.

--immediato

-i Visualizza immediatamente i risultati (non aspettare solo la fine).

--linea singola

-S Visualizza come singola riga di output di testo per ogni hit. Utile per interagire
con strumenti di compilazione.

--Omittime Ometti le informazioni sui tempi. Questo è utile per i test di regressione di faultfinder
stesso, in modo che l'output non vari a seconda della durata dell'analisi
prende.

--silenzioso

-Q Non visualizzare le informazioni sullo stato (ad esempio, quali file vengono esaminati) mentre
l'analisi è in corso.

Lista dei successi Management
--savehitlist=F
Salva tutti i risultati risultanti (la "lista dei successi") in F.

--loadhitlist=F
Carica la hitlist da F invece di analizzare i programmi sorgente. Avvertenza: fare non
caricare le hitlist da fonti non attendibili (per motivi di sicurezza).

--diffhitlist=F
Mostra solo i risultati (caricati o analizzati) non in F. F è stato presumibilmente creato
utilizzando in precedenza --savehitlist. Avvertenza: fare non diff hitlist da untrusted
fonti (per motivi di sicurezza). Se l'opzione --loadhitlist non è fornita,
questo mostrerà i risultati nei file di codice sorgente analizzati che non lo erano
precedentemente memorizzato in F. Se usato insieme a --loadhitlist, questo mostrerà il
hit nella hitlist caricata non in F. L'algoritmo di differenza è
conservatore; i risultati sono considerati "uguali" solo se hanno lo stesso
nome file, numero di riga, posizione della colonna, nome della funzione e livello di rischio.

ESEMPI

Di seguito sono riportati vari esempi di come invocare il rilevatore di difetti. I primi esempi mostrano vari
semplici opzioni della riga di comando. Flawfinder è progettato per funzionare bene con editor di testo e
ambienti di sviluppo integrati, quindi le sezioni successive mostrano come integrare il rilevatore di difetti
in vim ed emacs.

Un'espansione Da riga di comando Opzioni
cercatore di difetti /usr/src/linux-3.16
Esaminare tutti i file C/C++ nella directory /usr/src/linux-3.16 e tutti i suoi
sottodirectory (in modo ricorsivo), riportando tutti gli hit trovati. Per impostazione predefinita
faultfinder salterà i link simbolici e le directory con nomi che iniziano con
un periodo.

cercatore di difetti --livellomin=4 .
Esamina tutti i file C/C++ nella directory corrente e nelle sue sottodirectory
(ricorsivamente); segnalare solo le vulnerabilità di livello 4 e superiori (i due più alti
livelli di rischio).

cercatore di difetti --input miadir
Esaminare tutti i file C/C++ in mydir e le sue sottodirectory (in modo ricorsivo) e
funzioni di report che accettano input (in modo che tu possa assicurarti che filtrino il
input in modo appropriato).

cercatore di difetti --non ignorare miadir
Esaminare tutti i file C/C++ nella directory mydir e nelle sue sottodirectory,
inclusi anche i risultati contrassegnati per l'ignoranza nei commenti del codice.

cercatore di difetti -QD miadir
Esaminare mydir e riportare solo i risultati effettivi (rimuovendo l'intestazione e
piè di pagina dell'output). Questo modulo è utile se l'output verrà reindirizzato in
altri strumenti per ulteriori analisi. Il -C (--colonne) e -S (--singleline)
le opzioni possono essere utili anche se stai convogliando i dati in altri strumenti.

cercatore di difetti -QDSC miadir
Esaminare mydir, riportando solo i risultati effettivi (nessuna intestazione o piè di pagina). Ogni
hit viene riportato su una riga e vengono riportati i numeri di colonna. Questo può essere un
comando utile se stai inviando l'output di faultfinder ad altri strumenti.

cercatore di difetti --silenzioso --html --contesto miadir > risultati.html
Esaminare tutti i file C/C++ nella directory mydir e nelle sue sottodirectory e
produrre una versione formattata HTML dei risultati. Gestione del codice sorgente
sistemi (come SourceForge e Savannah) potrebbero usare un comando come questo.

cercatore di difetti --silenzioso --savehitlist hit.salvati *.[cap]
Esamina tutti i file .c e .h nella directory corrente. Non riferire sul
stato dell'elaborazione e salvare la hitlist risultante (l'insieme di tutte le hit) in
il file save.hits.

cercatore di difetti --diffhitlist hit.salvati *.[cap]
Esamina tutti i file .c e .h nella directory corrente e mostra tutti i risultati che
non erano già nel file save.hits. Questo può essere usato per mostrare solo il
Vulnerabilità ``nuove'' in un programma modificato, se save.hits è stato creato da
la versione precedente del programma in analisi.

cercatore di difetti --toppa recente.patch .
Esamina la directory corrente in modo ricorsivo, ma riporta solo le righe che erano
modificato o aggiunto nel file di patch già applicato denominato recente.patch.

cercatore di difetti --regex "CWE-120|CWE-126" src /
Esamina directory src ricorsivamente, ma riporta solo i risultati dove CWE-120 o
CWE-126 si applica.

Invocando da vim
L'editor di testo vim include un meccanismo di "riparazione rapida" che funziona bene con il cercatore di difetti, quindi
che puoi facilmente visualizzare i messaggi di avviso e passare al codice sorgente pertinente.

Innanzitutto, devi invocare la ricerca difetti per creare un elenco di risultati e ci sono due modi per farlo
Fai questo. Il primo modo è avviare prima la ricerca difetti e poi (usando il suo output) invocare
vim. Il secondo modo è avviare (o continuare a eseguire) vim e quindi invocare la ricerca difetti
(tipicamente dall'interno di vim).

Per il primo modo, esegui il cercatore di difetti e memorizza il suo output in alcuni FLAWFILE (diciamo "flawfile"),
quindi invocare vim usando la sua opzione -q, in questo modo: "vim -q difetto file". Il secondo modo
(iniziare a trovare difetti dopo aver avviato vim) può essere fatto in una miriade di modi. Uno è invocare
faultfinder usando un comando shell, ":!flawfinder-command > FLAWFILE", quindi seguilo con
il comando ":cf FLAWFILE". Un altro modo è memorizzare il comando di ricerca difetti nel tuo
makefile (come, ad esempio, uno pseudocomando come "flaw"), quindi eseguire ":make fault".

In tutti questi casi è necessario un comando per l'esecuzione di faultfinder. Un comando plausibile, che
posiziona ogni hit nella propria riga (-S) e rimuove intestazioni e piè di pagina che potrebbero confondere
è:

cercatore di difetti -SQD .

Ora puoi utilizzare vari comandi di modifica per visualizzare i risultati. Viene visualizzato il comando ":cn"
il prossimo colpo; ":cN" visualizza la hit precedente e ":cr" torna indietro alla prima hit.
":copen" aprirà una finestra per mostrare l'elenco attuale dei risultati, chiamata "quickfix
window"; ":cclose" chiuderà la finestra di correzione rapida. Se il buffer nella finestra utilizzata ha
modificato e l'errore si trova in un altro file, il passaggio all'errore fallirà. Si deve
assicurati che la finestra contenga un buffer che può essere abbandonato prima di provare a saltare a a
nuovo file, ad esempio salvando il file; questo impedisce la perdita accidentale di dati.

Invocando da emacs
L'editor di testo / sistema operativo emacs include "modalità grep" e "modalità compilazione"
meccanismi che funzionano bene con il rilevatore di difetti, semplificando la visualizzazione dei messaggi di avviso, salta
al codice sorgente pertinente e risolvi gli eventuali problemi riscontrati.

Innanzitutto, è necessario invocare il rilevatore di difetti per creare un elenco di messaggi di avviso. Puoi usare
"modalità grep" o "modalità compilazione" per creare questo elenco. Spesso la "modalità grep" è più conveniente;
lascia intatta la modalità di compilazione in modo che tu possa facilmente ricompilare una volta che hai cambiato
qualcosa. Tuttavia, se vuoi saltare alla posizione esatta della colonna di un hit, compila
potrebbe essere più conveniente perché emacs può usare l'output della colonna di faultfinder per
salta direttamente alla posizione giusta senza alcuna configurazione speciale.

Per utilizzare la modalità grep, inserisci il comando "Mx grep" e quindi inserisci il rilevatore di difetti necessario
comando. Per utilizzare la modalità di compilazione, inserisci il comando "Mx compile" e inserisci il necessario
comando cerca difetti. Questo è un comando meta-chiave, quindi dovrai usare la meta chiave per
la tastiera (di solito è il tasto ESC). Come con tutti i comandi di emacs, dovrai
premere INVIO dopo aver digitato "grep" o "compila". Quindi su molti sistemi, la modalità grep è
invocato digitando ESC xgrep RETURN.

È quindi necessario inserire un comando, rimuovendo ciò che era presente prima, se necessario. UN
comando plausibile è:

cercatore di difetti -SQDC .

Questo comando rende ogni rapporto sui risultati una singola riga, il che è molto più facile da fare per gli strumenti
maneggiare. Le opzioni quiet e dataonly rimuovono le altre informazioni di stato non necessarie per
utilizzare all'interno di emacs. Il punto finale significa che la directory corrente e tutto
i discendenti vengono ricercati per codice C/C++ e analizzati per individuare eventuali difetti.

Una volta che hai invocato la ricerca di difetti, puoi usare emacs per saltare nei suoi risultati. Il
comando Cx ` (Control-x backtick) visita la posizione del codice sorgente per il prossimo avviso
Messaggio. Cu Cx ` (control-u control-x backtick) ricomincia dall'inizio. Puoi
visita la fonte per qualsiasi messaggio di errore particolare spostandoti su quel messaggio di successo nel
*compilation* buffer o *grep* buffer e digitando il tasto Invio. (Nota tecnica: nel
buffer di compilazione, questo richiama compile-goto-error.) Puoi anche fare clic con il mouse-2
pulsante sul messaggio di errore (non è necessario passare prima al buffer di *compilazione*).

Se vuoi usare la modalità grep per saltare a colonne specifiche di un risultato, dovrai farlo
configurare appositamente emacs per farlo. Per fare ciò, modifica la variabile emacs "grep-regexp-
alist". Questa variabile dice a Emacs come analizzare l'output di un comando "grep", simile al
variabile "compilation-error-regexp-alist" che elenca vari formati di errore di compilazione
messaggi.

Invocando da Integrato Mercato Ambienti (IDE)
Per (altri) IDE, consulta il set di plug-in del tuo IDE.

COMUNI DEBOLEZZA ENUMERAZIONE (CWE)

La Common Weakness Enumeration (CWE) è ``un elenco formale o dizionario di software comune
debolezze che possono verificarsi nell'architettura, nella progettazione, nel codice o nell'implementazione del software che
può portare a vulnerabilità di sicurezza sfruttabili... create per fungere da linguaggio comune
per descrivere i punti deboli della sicurezza del software'' (http://cwe.mitre.org/about/faq.html). Per
maggiori informazioni sui CWE, vedi http://cwe.mitre.org.

Flawfinder supporta il CWE ed è ufficialmente compatibile con CWE. Di solito le descrizioni dei colpi
includere un identificatore di Common Weakness Enumeration (CWE) pertinente tra parentesi dove c'è
è noto per essere un CWE rilevante. Ad esempio, molti degli hit relativi al buffer menzionano
CWE-120, l'identificatore CWE per ``copia buffer senza controllare la dimensione dell'input'' (aka
``Overflow del buffer classico''). In alcuni casi può essere elencato più di un identificatore CWE.
Il report HTML include anche collegamenti ipertestuali alle definizioni CWE ospitate presso MITRE. In
in questo modo, il rilevatore di difetti è progettato per soddisfare il requisito CWE-Output.

Molti dei CWE segnalati da faultfinder sono identificati nella lista dei 25 migliori CWE/SANS 2011
(http://cwe.mitre.org/top25/). Molte persone vorranno cercare CWE in questo elenco,
come CWE-120 (classic buffer overflow), quando il rilevatore di difetti si mappa su un CWE che è più
generale di una delle prime 25 voci, la elenca come più generale: più specifica (ad es.
CWE-119:CWE-120), dove più generale è la mappatura effettiva. Se il cercatore di difetti si associa a un altro
elemento CWE specifico che è un caso specifico di un elemento tra i primi 25, è elencato nel modulo
top-25/più specifico (es. CWE-362/CWE-367), dove la mappatura reale è la più specifica
ingresso CWE. Se la stessa voce è mappata su più CWE, i CWE sono separati da virgole
(questo si verifica spesso con CWE-20, Convalida dell'input improprio). Questo semplifica la ricerca di
alcuni CWE.

Per la mappatura è stata utilizzata la versione CWE 2.7 (rilasciata il 23 giugno 2014). L'attuale CWE
le mappature selezionano il CWE più specifico che lo strumento può determinare. In teoria, la maggior parte CWE
elementi di sicurezza (firme/schemi che lo strumento cerca) potrebbero teoricamente essere
mappato su CWE-676 (Uso della funzione potenzialmente pericolosa), ma tale mappatura non sarebbe
utile. Pertanto, sono state preferite mappature più specifiche dove è possibile trovarne una. Rilevatore di difetti
è uno strumento di analisi lessicale; di conseguenza, non è pratico che sia più specifico di
le mappature attualmente implementate. Questo significa anche che è improbabile che serva molto
aggiornamento per valuta mappa; semplicemente non ha abbastanza informazioni per definire a
livello CWE dettagliato che le modifiche CWE in genere influenzerebbero. L'elenco degli identificatori CWE
è stato generato automaticamente usando "make show-cwes", quindi c'è sicurezza che questo elenco
è corretta. Si prega di segnalare i problemi di mappatura CWE come bug se ne trovate.

Flawfinder potrebbe non riuscire a trovare una vulnerabilità, anche se il difetto copre uno di questi CWE
debolezze. Detto questo, il rilevatore di difetti trova le vulnerabilità elencate dai CWE che copre,
e in molti casi non riporterà righe prive di tali vulnerabilità. Così, come
richiesto per qualsiasi strumento che intenda essere compatibile con CWE, il rilevatore di difetti ha un tasso di falso
positivi inferiori al 100% e un tasso di falsi negativi inferiore al 100%. Flawfinder quasi
segnala sempre ogni volta che trova una corrispondenza con un elemento di sicurezza CWE (una firma/schema come
definito nel suo database), sebbene alcuni costrutti oscuri possano causarne il fallimento (vedi BUG
sotto).

Flawfinder può segnalare i seguenti CWE (questi sono i CWE coperti da difetto di ricerca;
``*'' contrassegna quelli nella lista dei primi 25 CWE/SANS):

· CWE-20: Convalida dell'input improprio

· CWE-22: Limitazione impropria di un nome di percorso a una directory ristretta (``Path Traversal'')

· CWE-78: neutralizzazione impropria di elementi speciali utilizzati in un comando OS (``OS Command
Iniezione'')*

· CWE-119: Limitazione impropria delle operazioni all'interno dei limiti di un buffer di memoria (a
genitore di CWE-120*, quindi questo viene mostrato come CWE-119:CWE-120)

· CWE-120: Copia buffer senza controllare la dimensione dell'input (``Classic Buffer Overflow'')*

· CWE-126: sovralettura buffer

· CWE-134: Stringa di formato non controllata*

· CWE-190: Integer Overflow o Wraparound*

· CWE-250: esecuzione con privilegi non necessari

· CWE-327: utilizzo di un algoritmo crittografico non funzionante o rischioso*

· CWE-362: esecuzione simultanea utilizzando risorse condivise con sincronizzazione impropria
(``Condizioni di gara'')

· CWE-377: file temporaneo non sicuro

· CWE-676: Utilizzo di funzioni potenzialmente pericolose*

· CWE-732: Assegnazione autorizzazione errata per risorsa critica*

· CWE-785: uso della funzione di manipolazione del percorso senza buffer di dimensioni massime (figlio di
CWE-120*, quindi viene mostrato come CWE-120/CWE-785)

· CWE-807: affidamento su input non attendibili in una decisione di sicurezza*

· CWE-829: Inclusione di funzionalità dalla sfera di controllo non attendibile*

È possibile selezionare un sottoinsieme specifico di CWE da segnalare utilizzando l'opzione ``--regex'' (-e).
Questa opzione accetta un'espressione regolare, quindi puoi selezionare più CWE, ad esempio ``--regex
"CWE-120|CWE-126"''. Se selezioni più CWE con ``|'' su una riga di comando, lo farai
in genere è necessario citare i parametri (poiché un ``|'' senza virgolette è il simbolo della pipe).
Flawfinder è progettato per soddisfare il requisito CWE-Searchable.

Se il tuo obiettivo è segnalare un sottoinsieme di CWE elencati in un file, ciò può essere raggiunto
su un sistema simile a Unix usando l'opzione ``--regex'' alias ``-e''. Il file deve essere in
formato di espressione regolare. Ad esempio, ``flawfinder -e $(cat file1)'' riporterebbe solo
hit che corrispondono allo schema in ``file1''. Se file1 conteneva ``CWE-120|CWE-126'' esso
riporterebbe solo i risultati corrispondenti a quei CWE.

Un elenco di tutti gli elementi di sicurezza di CWE (le firme/pattern che ricerca difetti cerca)
può essere trovato usando l'opzione ``--listrules''. Ogni riga elenca il token della firma
(tipicamente un nome di funzione) che può portare a un hit, il livello di rischio predefinito e il
avviso predefinito (che include l'identificatore CWE predefinito). Per la maggior parte degli scopi questo è
anche abbastanza se vuoi vedere quali elementi di sicurezza CWE mappano a quali CWE o il
inversione. Ad esempio, per vedere la maggior parte delle firme (nomi di funzioni) che si associano a
CWE-327, senza vedere il livello di rischio predefinito o il testo di avviso dettagliato, eseguire ``flawfinder
--listrules | grep CWE-327 | taglia -f1''. Puoi anche vedere i token senza una mappatura CWE
in questo modo eseguendo ``flawfinder -D --listrules | grep -v CWE-''. Tuttavia, mentre
--listrules elenca tutti gli elementi di sicurezza CWE, elenca solo le mappature predefinite da CWE
elementi di sicurezza agli identificatori CWE. Non include i perfezionamenti che trova difetti
si applica (ad esempio, esaminando i parametri di funzione).

Se desideri una mappatura dettagliata ed esatta tra gli elementi di sicurezza CWE e CWE
identificatori, il codice sorgente di faultfinder (incluso nella distribuzione) è il posto migliore
per quell'informazione. Queste informazioni dettagliate sono principalmente di interesse per quei pochi
persone che stanno cercando di perfezionare le mappature CWE di faultfinder o di perfezionare CWE in generale.
Il codice sorgente documenta la mappatura tra gli elementi di sicurezza al rispettivo CWE
identificatori ed è un singolo file Python. Il set di dati ``c_rules'' definisce la maggior parte delle regole,
con riferimento ad una funzione che può apportare ulteriori affinamenti. Puoi cercare in
set di dati per i nomi delle funzioni per vedere cosa CWE genera per impostazione predefinita; se il primo parametro è
non ``normal'' allora questo è il nome di un metodo Python di raffinamento che potrebbe selezionare diversi
CWE (a seconda di ulteriori informazioni). Al contrario, puoi cercare "numero CWE"
e trova quali elementi di sicurezza (firme o modelli) si riferiscono a quell'identificatore CWE.
Per la maggior parte delle persone, questo è molto più del necessario; la maggior parte delle persone vuole solo scansionare il proprio
codice sorgente per trovare rapidamente i problemi.

SICUREZZA

Il punto centrale di questo strumento è aiutare a trovare le vulnerabilità in modo che possano essere risolte.
Tuttavia, sviluppatori e revisori devono sapere come sviluppare software sicuro per utilizzarlo
strumento, perché altrimenti a ingannare con a is ancora a ingannare. Il mio libro su
http://www.dwheeler.com/secure-programs posso aiutare.

Questo strumento dovrebbe essere, al massimo, una piccola parte di un processo di sviluppo software più ampio
progettati per eliminare o ridurre l'impatto delle vulnerabilità. Sviluppatori e revisori
hanno bisogno di sapere come sviluppare software sicuro e hanno bisogno di applicare questa conoscenza per ridurre
i rischi di vulnerabilità in primo luogo.

Diversi strumenti di rilevamento delle vulnerabilità tendono a trovare diverse vulnerabilità. Così, tu
è meglio usare la revisione umana e una varietà di strumenti. Questo strumento può aiutare a trovare qualcosa
vulnerabilità, ma non tutte.

Dovresti sempre analizzare un copia del programma sorgente analizzato, non una directory
che può essere modificato da uno sviluppatore mentre il rilevatore di difetti esegue l'analisi. Questo è
particolarmente true se non ti fidi necessariamente di uno sviluppatore del programma analizzato.
Se un utente malintenzionato ha il controllo sui file mentre li stai analizzando, l'aggressore potrebbe
spostare i file o modificarne il contenuto per evitare l'esposizione di un problema di sicurezza
(o creare l'impressione di un problema dove non c'è). Se sei preoccupato per
programmatori malintenzionati dovresti farlo comunque, perché dopo l'analisi dovrai farlo
verifica che il codice eventualmente eseguito sia il codice che hai analizzato. Inoltre, non utilizzare il
opzione --allowlink in questi casi; gli aggressori potrebbero creare collegamenti simbolici dannosi ai file
al di fuori della loro area del codice sorgente (come /etc/passwd).

I sistemi di gestione del codice sorgente (come SourceForge e Savannah) rientrano sicuramente in questo
categoria; se stai mantenendo uno di quei sistemi, prima copia o estrai i file in
una directory separata (che non può essere controllata dagli aggressori) prima di eseguire il rilevatore di difetti o
qualsiasi altro strumento di analisi del codice.

Nota che il rilevatore di difetti apre solo file, directory e (se richiesto) simbolici normali
collegamenti; non aprirà mai altri tipi di file, anche se ad essi viene creato un collegamento simbolico.
Ciò contrasta gli aggressori che inseriscono tipi di file insoliti nel codice sorgente. Tuttavia, questo
funziona solo se il filesystem analizzato non può essere modificato da un utente malintenzionato durante il
analisi, come suggerito sopra. Questa protezione non funziona nemmeno sulle piattaforme Cygwin,
Sfortunatamente.

I sistemi Cygwin (emulazione Unix su Windows) hanno un problema aggiuntivo se il rilevatore di difetti
viene utilizzato per analizzare programmi di cui l'analista non può fidarsi. Il problema è dovuto a un design
difetto in Windows (che eredita da MS-DOS). Su Windows e MS-DOS, alcuni nomi di file
(ad es. ``com1'') sono trattati automaticamente dal sistema operativo come i nomi di
periferiche, e questo è vero anche quando viene fornito un percorso completo. Sì, Windows e MS-DOS
sono davvero progettati così male. Flawfinder si occupa di questo controllando cos'è un filesystem
oggetto è, quindi solo l'apertura di directory e file regolari (e collegamenti simbolici se abilitati).
Sfortunatamente, questo non funziona su Cygwin; su almeno alcune versioni di Cygwin su alcune
versioni di Windows, il semplice tentativo di determinare se un file è un tipo di dispositivo può causare il
programma da appendere. Una soluzione alternativa consiste nell'eliminare o rinominare tutti i nomi di file che vengono interpretati
come nomi di dispositivi prima di eseguire l'analisi. Questi cosiddetti ``nomi riservati'' sono
CON, PRN, AUX, CLOCK$, NUL, COM1-COM9 e LPT1-LPT9, facoltativamente seguito da un'estensione
(ad esempio, ``com1.txt''), in qualsiasi directory e in ogni caso (Windows non fa distinzione tra maiuscole e minuscole).

Do non caricare o differenziare le hitlist da fonti non attendibili. Sono implementati utilizzando il
Python pickle module, e il modulo pickle non è concepito per essere sicuro contro errori
o dati maliziosamente costruiti. Le hitlist memorizzate sono intese per un uso successivo da parte degli stessi
utente che ha creato la hitlist; in quel contesto questa restrizione non è un problema.

Usa il rilevatore di difetti online utilizzando i servizi onworks.net