foutzoeker - Online in de cloud

PROGRAMMA:

NAAM

faultfinder - vind lexicaal potentiële beveiligingsfouten ("hits") in de broncode

KORTE INHOUD

foutzoeker [--help|-h] [--versie] [--lijstregels]
[--allowlink] [--volgdotdir] [--geen link]
[--patch=bestandsnaam|-P bestandsnaam]
[-- ingangen|-I] [ --minniveau=X | -m X ] [--vals positief|-F]
[--nooit negeren|-n]
[--regex=PATROON | -e PATROON]
[--context|-c] [--kolommen|-C] [--alleen gegevens|-D] [--html|-H] [--onmiddellijk|-i]
[--enkele lijn|-S] [--tijd overslaan] [--stil|-Q]
[--loadhitlijst=F] [--savehitlijst=F] [--diffhitlijst=F]
[--] [ (bron) code filet or (bron) wortel directory ]+

PRODUCTBESCHRIJVING

Flawfinder doorzoekt de C/C++-broncode op zoek naar mogelijke beveiligingsfouten. Naar
voer de foutzoeker uit, geef gewoon de foutzoeker een lijst met mappen of bestanden. Voor elke map
gegeven, alle bestanden met C/C++ bestandsnaamextensies in die map (en zijn
submappen, recursief) worden onderzocht. Geef dus voor de meeste projecten gewoon
faultfinder de naam van de bovenste map van de broncode (gebruik ``.'' voor de huidige
directory), en zal faultfinder alle C/C++-broncode van het project onderzoeken. als jij
alleen willen hebben veranderingen beoordeeld, slaat u een uniforme diff van die wijzigingen op (gemaakt door GNU
"diff -u" of "svn diff" of "git diff") in een patchbestand en gebruik de optie --patch (-P).

Flawfinder zal een lijst met ``hits'' (potentiële beveiligingslekken) produceren, gesorteerd op risico; de
de meest riskante treffers worden als eerste getoond. Het risiconiveau wordt tussen vierkante haken weergegeven en varieert
van 0, heel weinig risico, tot 5, groot risico. Dit risiconiveau is niet alleen afhankelijk van de
functie, maar op de waarden van de parameters van de functie. Bijvoorbeeld constant
strings zijn in veel contexten vaak minder riskant dan volledig variabele strings
contexten zal de treffer een lager risiconiveau hebben. Flawfinder weet van gettext (een veelgebruikt
bibliotheek voor geïnternationaliseerde programma's) en behandelt constante reeksen die worden doorgegeven
gettext alsof het constante strings zijn; dit vermindert het aantal valse hits in
geïnternationaliseerde programma's. Flawfinder zal hetzelfde doen met _T() en
_TEXT(), algemene Microsoft-macro's voor het verwerken van geïnternationaliseerde programma's. Foutzoeker
negeert correct de meeste tekst in opmerkingen en tekenreeksen. Normaal gesproken toont de foutzoeker alles
treffers met een risiconiveau van minimaal 1, maar u kunt de optie --minlevel gebruiken om alleen te tonen
hits met hogere risiconiveaus als je dat wilt. Hitbeschrijvingen vermelden ook de relevante Common
Weakness Enumeration (CWE) identifier(s) tussen haakjes, zoals hieronder besproken. Foutzoeker
is officieel CWE-compatibel.

Niet elke hit is eigenlijk een beveiligingsprobleem, en niet elk beveiligingsprobleem
wordt noodzakelijkerwijs gevonden. Desalniettemin kan de foutzoeker een hulpmiddel zijn bij het vinden en verwijderen
beveiligingsproblemen. Een veelgebruikte manier om faultfinder te gebruiken is om eerst faultfinder toe te passen op
een set broncode en onderzoek de items met het hoogste risico. Gebruik dan --inputs om te onderzoeken
de invoerlocaties en controleer of er alleen legale en veilige invoerwaarden zijn
geaccepteerd van niet-vertrouwde gebruikers.

Nadat u een programma hebt gecontroleerd, kunt u broncoderegels markeren die eigenlijk prima zijn
onechte waarschuwingen veroorzaken, zodat de foutzoeker stopt met klagen. Om een ​​te markeren
regel zodat deze waarschuwingen worden onderdrukt, plaatst u een speciaal opgemaakte opmerking op
dezelfde regel (na de broncode) of helemaal alleen in de vorige regel. De reactie
moet een van de volgende twee indelingen hebben:

· // Flawfinder: negeren

· /* Flawfinder: negeren */

Omwille van de compatibiliteit kunt u "Flawfinder:" vervangen door "ITS4:" of "RATS:" in deze
speciaal opgemaakte opmerkingen. Aangezien het mogelijk is dat dergelijke regels verkeerd zijn, kunt u gebruiken
de optie --neverignore, die ervoor zorgt dat de foutzoeker nooit een regel negeert, wat er ook gebeurt
de commentaarrichtlijnen zeggen (meer verwarrend, --neverignore negeert de negeert).

Flawfinder gebruikt een interne database genaamd de ``ruleset''; de regelset identificeert
functies die veelvoorkomende oorzaken zijn van beveiligingsfouten. De standaard regelset bevat een grote
aantal verschillende potentiële problemen, waaronder beide algemene problemen die van invloed kunnen zijn
C/C++-programma, evenals een aantal specifieke Unix-achtige en Windows-functies die dat wel zijn
vooral problematisch. De optie --listrules rapporteert de lijst met huidige regels en
hun wanbetalingsrisiconiveaus. Zoals hierboven vermeld, is elke mogelijke beveiligingsfout die in een gegeven wordt gevonden
broncodebestand (dat overeenkomt met een invoer in de regelset) wordt een ``hit'' genoemd en de set van
treffers gevonden tijdens een bepaalde uitvoering van het programma wordt de ``hitlijst'' genoemd. Hitlijsten
kan worden opgeslagen (met behulp van --savehitlist), opnieuw worden geladen om opnieuw te worden weergegeven (met behulp van --loadhitlist), en
je kunt alleen de treffers tonen die verschillen van een andere run (met behulp van --diffhitlist).

Flawfinder is een eenvoudig hulpmiddel, wat leidt tot enkele fundamentele voor- en nadelen. Foutzoeker werkt
door eenvoudige lexicale tokenisatie uit te voeren (opmerkingen overslaan en tekenreeksen correct tokeniseren),
zoeken naar tokenovereenkomsten met de database (met name om functieaanroepen te vinden).
Flawfinder is dus vergelijkbaar met RATS en ITS4, die ook eenvoudige lexicale tokenisatie gebruiken.
Flawfinder onderzoekt vervolgens de tekst van de functieparameters om het risico in te schatten. in tegenstelling tot
tools zoals spalk, gcc's waarschuwingsvlaggen en clang, faultfinder doet niet gebruiken of hebben
toegang tot informatie over besturingsstroom, gegevensstroom of gegevenstypen bij het zoeken naar
potentiële kwetsbaarheden of het inschatten van het risiconiveau. Foutzoeker zal dus
produceren noodzakelijkerwijs veel valse positieven voor kwetsbaarheden en rapporteren er niet veel
kwetsbaarheden. Aan de andere kant kan faultfinder kwetsbaarheden vinden in programma's die
kan niet worden gebouwd of kan niet worden gekoppeld. Het kan vaak werken met programma's die dat niet eens kunnen zijn
samengesteld (althans door de tools van de recensent). Flawfinder raakt ook niet zo in de war door
macrodefinities en andere eigenaardigheden waar meer geavanceerde tools moeite mee hebben.
Flawfinder kan ook nuttig zijn als een eenvoudige introductie tot statische analysetools in
algemeen, omdat het gemakkelijk te gebruiken en gemakkelijk te begrijpen is.

Elke bestandsnaam die op de opdrachtregel wordt gegeven, wordt onderzocht (zelfs als deze geen gebruikelijke
C/C++ bestandsnaamextensie); dus je kunt de foutzoeker dwingen om specifieke bestanden te onderzoeken
wens. Tijdens het recursief doorzoeken van mappen, wordt de foutzoeker alleen geopend en onderzocht
reguliere bestanden met C/C++ bestandsnaamextensies. Flawfinder gaat ervan uit dat bestanden
C/C++-bestanden als ze de extensies ".c", ".h", ".ec", ".ecp", ".pgc", ".C", ".cpp",
".CPP", ".cxx", ".cc", ".CC", ".pcc", ".hpp" of ".H". De bestandsnaam ``-'' betekent de
standaard invoer. Om beveiligingsproblemen te voorkomen, worden speciale bestanden (zoals speciale apparaatbestanden
en named pipes) worden altijd overgeslagen, en symbolische links worden standaard overgeslagen (de
--allowlink optie volgt symbolische links).

Na de lijst met treffers staat een korte samenvatting van de resultaten (gebruik -D om dit te verwijderen
informatie). Het toont het aantal treffers, geanalyseerde lijnen (zoals gerapporteerd door wc -l), en
de fysieke bronregels code (SLOC) geanalyseerd. Een fysieke SLOC is een niet-lege, niet-
commentaar regel. Het toont dan het aantal treffers op elk niveau; merk op dat er zal
wees nooit een hit op een niveau lager dan het minimumniveau (standaard 1). Dus "[0] 0 [1] 9"
betekent dat er op niveau 0 0 treffers zijn gemeld en op niveau 1 9 treffers
gemeld. Vervolgens wordt het aantal treffers weergegeven op een bepaald niveau of groter (dus niveau 3+
heeft de som van het aantal treffers op niveau 3, 4 en 5). Dus een invoer van "[0+] 37"
laat zien dat er op niveau 0 of hoger 37 treffers waren (de 0+ invoer zal altijd hetzelfde zijn
als het "hits"-nummer hierboven). Hits per KSLOC wordt vervolgens getoond; dit is elk van de "niveau of
hogere" waarden vermenigvuldigd met 1000 en gedeeld door de fysieke SLOC. Als symlinks waren
overgeslagen, wordt het aantal daarvan gerapporteerd. Als treffers werden onderdrukt (met behulp van de "ignore"
instructie in broncodecommentaar zoals hierboven beschreven), wordt het onderdrukte nummer gerapporteerd.
Het minimale risiconiveau dat in het rapport moet worden opgenomen, wordt weergegeven; standaard is dit 1
(gebruik --minlevel om dit te veranderen). De samenvatting eindigt met belangrijke herinneringen: niet elke hit
is noodzakelijkerwijs een beveiligingsprobleem en er kunnen andere beveiligingsproblemen zijn
niet gemeld door de tool.

Flawfinder is uitgebracht onder de GNU GPL-licentie versie 2 of later (GPLv2+).

Flawfinder werkt op dezelfde manier als een ander programma, ITS4, dat niet volledig open source is
software (zoals gedefinieerd in de Open Source Definition) noch vrije software (zoals gedefinieerd door de
Stichting Vrije Software). De auteur van Flawfinder heeft de broncode van ITS4 nog nooit gezien.

KORT TUTORIAL

Hier is een kort voorbeeld van hoe foutzoeker kan worden gebruikt. Stel je voor dat je de C/C++ hebt
broncode voor een programma met de naam xyzzy (dat je al dan niet hebt geschreven), en
je bent op zoek naar beveiligingsproblemen (zodat je ze kunt oplossen voordat klanten
de kwetsbaarheden tegenkomen). Voor deze tutorial ga ik ervan uit dat je een Unix-
zoals Linux, OpenBSD of MacOS X.

Als de broncode zich in een subdirectory met de naam xyzzy bevindt, zou je waarschijnlijk beginnen met het openen van een
tekstvenster en gebruik van de standaardinstellingen van de foutzoeker om het programma te analyseren en te rapporteren
geprioriteerde lijst van potentiële beveiligingskwetsbaarheden (de ``minder'' zorgt er gewoon voor dat de
resultaten blijven op het scherm):
foutzoeker xyzzy | minder

Op dit punt ziet u een groot aantal vermeldingen. Elk item heeft een bestandsnaam, een
dubbele punt, een regelnummer, een risiconiveau tussen haakjes (waarbij 5 het meest riskante is), een categorie,
de naam van de functie en een beschrijving waarom de foutzoeker denkt dat de regel een
kwetsbaarheid. Flawfinder sorteert normaal gesproken op risiconiveau, waarbij de meest risicovolle items eerst worden weergegeven;
als je weinig tijd hebt, is het waarschijnlijk het beste om te beginnen met werken aan de meest risicovolle items en
ga door tot je geen tijd meer hebt. Als u de weergave wilt beperken tot risico's met slechts a
een bepaald risiconiveau of hoger, gebruik dan de optie --minlevel. Als je een krijgt
buitengewoon aantal valse positieven omdat namen van variabelen er gevaarlijk uitzien
functienamen, gebruik de optie -F om rapporten erover te verwijderen. Als je het niet begrijpt
de foutmelding, zie documenten zoals de schrijf- Veilig Bestellen Programma's For Linux en
Unix HOE ⟨http://www.dwheeler.com/secure-programs⟩ bij http://www.dwheeler.com/secure-
programma's met meer informatie over het schrijven van veilige programma's.

Zodra u het probleem identificeert en begrijpt, kunt u het oplossen. Af en toe mag
de analyse opnieuw wilt doen, beide omdat de regelnummers zullen veranderen en om er zeker van te zijn
dat de nieuwe code nog geen andere kwetsbaarheid introduceert.

Als je hebt vastgesteld dat een lijn niet echt een probleem is, en je bent er zeker van, dan kan dat
plaats vlak voor of op de gewraakte regel een opmerking zoals
/* Flawfinder: negeren */
om te voorkomen dat ze in de uitvoer verschijnen.

Als je dat eenmaal hebt gedaan, moet je teruggaan en zoeken naar de invoer van het programma om te maken
zorg ervoor dat het programma alle niet-vertrouwde invoer sterk filtert. Foutzoeker kan
identificeer veel programma-invoer door de optie --inputs te gebruiken, zoals deze:
foutzoeker --voert xyzzy in

Flawfinder kan goed worden geïntegreerd met teksteditors en geïntegreerde ontwikkelomgevingen;
zie de voorbeelden voor meer informatie.

Flawfinder bevat vele andere opties, waaronder opties om HTML-versies van het
uitvoer (handig voor mooiere weergaven). In het volgende gedeelte worden die opties in meer beschreven
detail.

OPTIES

Flawfinder heeft een aantal opties, die kunnen worden gegroepeerd in opties die de zijne beheersen
documentatie, selecteer invoergegevens, selecteer welke treffers moeten worden weergegeven, selecteer het uitvoerformaat,
en hitlijstbeheer uitvoeren. Flawfinder ondersteunt de standaardsyntaxis die is gedefinieerd in de
POSIX (Issue 7, 2013 Edition) sectie ``Utility Conventies''. Het ondersteunt ook de GNU
lange opties (opties met dubbele streepjes van vorm --optie) zoals gedefinieerd in de GNU C Bibliotheek
Referentie Handmatig ``Syntaxisconventies voor programmaargumenten'' en GNU codering Normen
``Standaarden voor opdrachtregelinterfaces''. Lange optieargumenten kunnen worden opgegeven als
``--naam=waarde'' of ``-naam waarde''. Sommige opties zijn alleen toegankelijk via de more
leesbare GNU lange optieconventies; gemeenschappelijke opties worden ook ondersteund door de oudere
optieconventie van één letter.

Documentatie
--help

-h Toon gebruiksinformatie (help).

--versie Toont (alleen) het versienummer en sluit af.

--lijstregels Maak een lijst van de termen (tokens) die aanleiding geven tot verder onderzoek, hun wanbetalingsrisico
niveau, en de standaardwaarschuwing (inclusief de CWE-identificator(en), if
van toepassing), allemaal door tabs gescheiden. De termen zijn voornamelijk namen van potentieel-
gevaarlijke functies. Merk op dat het gerapporteerde risiconiveau en de waarschuwing voor sommigen
specifieke code kan afwijken van de standaard, afhankelijk van hoe de term is
gebruikt. Combineer met -D als je niet de gebruikelijke header wilt. Foutzoeker
versie 1.29 veranderde het scheidingsteken van spaties naar tabs en voegde de standaard toe
waarschuwingsveld.

Selecteren Invoer Data
--allowlink Sta het gebruik van symbolische links toe; normaal gesproken worden symbolische links overgeslagen. Niet doen
gebruik deze optie als u code van anderen analyseert; aanvallers kunnen veel doen
dingen die problemen veroorzaken voor een analyse met deze optie ingeschakeld. Voor
een aanvaller kan bijvoorbeeld symbolische koppelingen invoegen naar bestanden zoals / Etc / passwd
(lekken van informatie over het bestand) of maak een cirkellus, wat zou
ervoor zorgen dat de foutzoeker ``voor altijd'' draait. Een ander probleem om dit mogelijk te maken
optie is dat als er meerdere keren naar hetzelfde bestand wordt verwezen met behulp van symbolic
links, wordt het meerdere keren geanalyseerd (en dus meerdere keren gerapporteerd).
Merk op dat de foutzoeker al enige bescherming biedt tegen symbolische koppelingen
naar speciale bestandstypen zoals apparaatbestandstypen (bijv. /dev/zero of
C:\mystuff\com1). Merk op dat dit voor faultfinder versie 1.01 en eerder was
de standaard.

--volgdotdir
Voer mappen in waarvan de naam begint met ".". Normaal gesproken zijn dergelijke mappen
genegeerd, omdat ze normaal gesproken privégegevens voor versiebeheer bevatten (zoals
.git/ of .svn/), configuraties, enzovoort.

--geen link Buiten beschouwing gelaten. Historisch gezien heeft dit het volgen van symbolische links uitgeschakeld; dit gedrag
is nu de standaard.

--patch=patchbestand

-P patchbestand
Onderzoek de geselecteerde bestanden of mappen, maar rapporteer alleen treffers in regels die
worden toegevoegd of gewijzigd door het gegeven patchbestand. Het patchbestand moet in een
erkende uniforme diff-indeling (bijv. de uitvoer van GNU "diff -u oud nieuw",
"svn diff", of "git diff [commit]"). Flawfinder gaat ervan uit dat de patch
al toegepast op de bestanden. Het patchbestand kan ook wijzigingen bevatten in
irrelevante bestanden (deze worden simpelweg genegeerd). De regelnummers die in de
patch-bestand worden gebruikt om te bepalen welke regels zijn gewijzigd, dus als dat zo is
de bestanden heeft gewijzigd sinds het patchbestand is gemaakt, regenereert u het patchbestand opnieuw
Eerst. Pas op dat de bestandsnamen van de nieuwe bestanden die in het patchbestand worden gegeven
moet exact overeenkomen, inclusief hoofdletters/kleine letters, padvoorvoegsel en map
scheidingsteken (\ versus /). Alleen het uniforme diff-formaat wordt geaccepteerd (GNU diff, svn
diff, en git diff-uitvoer is in orde); als je een ander formaat hebt, nogmaals
eerst regenereren. Alleen treffers die voorkomen op resulterende gewijzigde regels, of
onmiddellijk erboven en eronder worden gerapporteerd. Deze optie impliceert
--nooit negeren.

Selecteren Hits naar Display
-- ingangen

-I Alleen functies weergeven die gegevens van buiten het programma verkrijgen; dit zet ook
minniveau naar 0.

--minniveau=X

-m X Stel minimaal risiconiveau in op X voor opname in hitlijst. Dit kan vanaf 0 (``no
risico'') tot 5 (``maximaal risico''); de standaardwaarde is 1.

--vals positief

-F Voeg geen treffers toe die waarschijnlijk fout-positieven zijn. Momenteel betekent dit
dat functienamen worden genegeerd als ze niet worden gevolgd door "(", en dat
declaraties van karakterarrays worden niet genoteerd. Dus als u een variabele gebruikt
overal "access" genoemd, dit zal verwijzingen naar dit gewone elimineren
variabel. Dit is niet de standaard, omdat dit ook de kans vergroot
belangrijke treffers missen; in het bijzonder functienamen in #define-clausules en -aanroepen
door middel van functie pointers zullen worden gemist.

--nooit negeren

-n Negeer beveiligingskwesties nooit, zelfs niet als ze een ``negeer''-richtlijn in een
commentaar.

--regexp=PATROON

-e PATROON
Rapporteer alleen treffers met tekst die overeenkomt met het reguliere-expressiepatroon PATTERN.
Om bijvoorbeeld alleen treffers te rapporteren die de tekst "CWE-120" bevatten, gebruikt u ``--regex
CWE-120''. Deze optievlagnamen zijn hetzelfde als grep.

Selecteren uitgang Formaat
--kolommen

-C Toon het kolomnummer (evenals de bestandsnaam en het regelnummer) van elke treffer;
dit wordt weergegeven na het regelnummer door een dubbele punt toe te voegen en het kolomnummer erin
de regel (het eerste teken in een regel is kolomnummer 1). Dit is handig
voor editors die naar specifieke kolommen kunnen springen, of voor integratie met andere
tools (zoals die om valse positieven verder uit te filteren).

--context

-c Toon context, dwz de regel met de "treffer"/potentiële fout. Standaard is de
regel wordt direct na de waarschuwing weergegeven.

--alleen gegevens

-D Geef de kop- en voettekst niet weer. Gebruik dit samen met --quiet om gewoon te zien
de gegevens zelf.

--html

-H Formatteer de uitvoer als HTML in plaats van als eenvoudige tekst.

--onmiddellijk

-i Toon direct treffers (wacht niet tot het einde).

--enkele lijn

-S Weergeven als enkele regel tekstuitvoer voor elke hit. Handig voor interactie
met compilatietools.

--tijd overslaan Laat timinginformatie weg. Dit is handig voor regressietesten van de foutzoeker
zelf, zodat de uitvoer niet varieert afhankelijk van hoe lang de analyse duurt
neemt.

--stil

-Q Geef geen statusinformatie weer (dwz welke bestanden worden onderzocht).
de analyse gaat door.

Hit lijst Management
--savehitlijst=F
Sla alle resulterende treffers (de "hitlijst") op in F.

--loadhitlijst=F
Laad de hitlijst van F in plaats van bronprogramma's te analyseren. Waarschuwing: doen niet
laad hitlijsten van niet-vertrouwde bronnen (om veiligheidsredenen).

--diffhitlijst=F
Toon alleen treffers (geladen of geanalyseerd) niet in F. F is vermoedelijk gemaakt
eerder --savehitlist gebruikt. Waarschuwing: doen niet diff hitlijsten van niet-vertrouwd
bronnen (om veiligheidsredenen). Als de --loadhitlist optie niet aanwezig is,
dit toont de hits in de geanalyseerde broncodebestanden die dat niet waren
eerder opgeslagen in F. Indien gebruikt samen met --loadhitlist, zal dit de
hits in de geladen hitlijst niet in F. Het verschilalgoritme is
conservatief; hits worden alleen als ``hetzelfde'' beschouwd als ze hetzelfde hebben
bestandsnaam, regelnummer, kolompositie, functienaam en risiconiveau.

Voorbeelden

Hier zijn verschillende voorbeelden van het aanroepen van faultfinder. De eerste voorbeelden laten verschillende zien
eenvoudige opdrachtregelopties. Flawfinder is ontworpen om goed te werken met teksteditors en
geïntegreerde ontwikkelomgevingen, dus laten de volgende paragrafen zien hoe u de foutzoeker integreert
in vim en emacs.

Eenvoudig command-line opties
foutzoeker /usr/src/linux-3.16
Onderzoek alle C/C++-bestanden in de map /usr/src/linux-3.16 en al zijn
submappen (recursief), rapportage over alle gevonden treffers. Standaard
faultfinder zal symbolische links en mappen met namen die beginnen met overslaan
een periode.

foutzoeker --minniveau=4 .
Onderzoek alle C/C++-bestanden in de huidige map en de bijbehorende submappen
(recursief); rapporteer alleen kwetsbaarheden van niveau 4 en hoger (de twee hoogste
risiconiveaus).

foutzoeker -- ingangen mijndir
Onderzoek alle C/C++-bestanden in mydir en zijn submappen (recursief), en
rapportfuncties die invoer accepteren (zodat u ervoor kunt zorgen dat ze de
correct invoeren).

foutzoeker --nooit negeren mijndir
Onderzoek alle C/C++-bestanden in de map mydir en zijn submappen,
inclusief zelfs de treffers die zijn gemarkeerd voor negeren in de codecommentaar.

foutzoeker -QD mijndir
Onderzoek mydir en rapporteer alleen de daadwerkelijke resultaten (verwijder de koptekst en
voettekst van de uitvoer). Dit formulier is handig als de uitvoer wordt doorgesluisd naar
andere tools voor verdere analyse. De -C (--kolommen) en -S (--enkele regel)
opties kunnen ook handig zijn als u de gegevens naar andere tools doorstuurt.

foutzoeker -QDSC mijndir
Onderzoek mydir en rapporteer alleen de daadwerkelijke resultaten (geen kop- of voettekst). Elk
hit wordt op één regel gerapporteerd en kolomnummers worden gerapporteerd. Dit kan een
nuttige opdracht als u foutzoekeruitvoer naar andere tools stuurt.

foutzoeker --stil --html --context mijndir > resultaten.html
Onderzoek alle C/C++-bestanden in de map mydir en zijn submappen, en
maak een HTML-geformatteerde versie van de resultaten. Broncode beheer
systemen (zoals SourceForge en Savannah) kunnen een dergelijk commando gebruiken.

foutzoeker --stil --hitlijst opslaan opgeslagen.treffers *.[ch]
Onderzoek alle .c- en .h-bestanden in de huidige map. Rapporteer niet over de
status van verwerking, en sla de resulterende trefferlijst (de set van alle treffers) op in
het bestand opgeslagen.hits.

foutzoeker --diffhitlijst opgeslagen.treffers *.[ch]
Onderzoek alle .c- en .h-bestanden in de huidige map en laat eventuele treffers zien
stonden nog niet in het bestand saved.hits. Dit kan worden gebruikt om alleen de
``nieuwe'' kwetsbaarheden in een aangepast programma, als saved.hits is gemaakt van
de oudere versie van het programma dat wordt geanalyseerd.

foutzoeker --lapje recente.patch .
Onderzoek de huidige directory recursief, maar rapporteer alleen regels die waren
gewijzigd of toegevoegd in het reeds aangebrachte patchbestand met de naam recente.patch.

foutzoeker --regex "CWE-120|CWE-126" src /
Onderzoek de map src recursief, maar rapporteer alleen hits waar CWE-120 of
CWE-126 is van toepassing.

Het aanroepen oppompen van vim
De teksteditor vim bevat een "quickfix"-mechanisme dat goed werkt met foutzoeker, dus
dat u de waarschuwingsberichten gemakkelijk kunt bekijken en naar de relevante broncode kunt springen.

Eerst moet u de foutzoeker aanroepen om een ​​lijst met treffers te maken, en er zijn twee manieren om dit te doen
doe dit. De eerste manier is om eerst de foutzoeker te starten en vervolgens (met behulp van de uitvoer) aan te roepen
vim. De tweede manier is om vim te starten (of door te gaan met uitvoeren) en vervolgens de foutzoeker aan te roepen
(meestal van binnenuit vim).

Voer voor de eerste manier de foutzoeker uit en sla de uitvoer op in een FLAWFILE (zeg "flawfile"),
roep dan vim aan met zijn -q optie, zoals dit: "vim -q foutbestand". De tweede manier
(foutzoeker starten na het starten van vim) kan op legio manieren worden gedaan. Een daarvan is aanroepen
faultfinder met behulp van een shell-commando, ":!flawfinder-command > FLAWFILE", en volg dat vervolgens met
het commando ":cf FLAWFILE". Een andere manier is om de opdracht faultfinder op te slaan in uw
makefile (als, laten we zeggen, een pseudocommando zoals "flaw"), en voer dan ":make fault" uit.

In al deze gevallen heb je een commando nodig om de foutzoeker uit te voeren. Een plausibele opdracht, welke
plaatst elke hit in zijn eigen regel (-S) en verwijdert kop- en voetteksten die verwarrend zouden kunnen zijn
het is:

foutzoeker -SQD .

U kunt nu verschillende bewerkingsopdrachten gebruiken om de resultaten te bekijken. Het commando ":cn" verschijnt
de volgende treffer; ":cN" geeft de vorige hit weer en ":cr" spoelt terug naar de eerste hit.
":copen" zal een venster openen om de huidige lijst met treffers te tonen, de zogenaamde "quickfix
window"; ":cclose" sluit het quickfix-venster. Als de buffer in het gebruikte venster is
gewijzigd en de fout zit in een ander bestand, zal het springen naar de fout mislukken. Je moet
zorg ervoor dat het venster een buffer bevat die kan worden verlaten voordat u probeert naar een te springen
nieuw bestand, bijvoorbeeld door het bestand op te slaan; dit voorkomt onbedoeld gegevensverlies.

Het aanroepen oppompen van emacs
De teksteditor / besturingssysteem emacs bevat "grep-modus" en "compileermodus"
mechanismen die goed werken met faultfinder, waardoor het gemakkelijk is om waarschuwingsberichten te bekijken, te springen
naar de relevante broncode en los eventuele problemen op.

Eerst moet u de foutzoeker aanroepen om een ​​lijst met waarschuwingsberichten te maken. Je kunt gebruiken
"grep-modus" of "compileermodus" om deze lijst te maken. Vaak is de "grep-modus" handiger;
het laat de compile-modus ongemoeid, zodat je gemakkelijk opnieuw kunt compileren als je eenmaal bent veranderd
iets. Als u echter naar de exacte kolompositie van een hit wilt springen, compileert u
modus kan handiger zijn omdat emacs de kolomuitvoer van foutzoeker kan gebruiken om
spring direct naar de juiste locatie zonder speciale configuratie.

Om de grep-modus te gebruiken, voert u het commando "Mx grep" in en voert u vervolgens de benodigde foutzoeker in
commando. Om de compile-modus te gebruiken, voert u het commando "Mx compile" in en voert u het benodigde in
foutzoeker commando. Dit is een metasleutelopdracht, dus u moet de metasleutel gebruiken voor
uw toetsenbord (dit is meestal de ESC-toets). Zoals met alle emacs-commando's, moet u dit doen
druk op RETURN na het typen van "grep" of "compileren". Dus op veel systemen is de grep-modus
aangeroepen door ESC xgrep RETURN te typen.

U moet dan een commando invoeren, waarbij u indien nodig verwijdert wat er eerder was. A
plausibele opdracht is:

foutzoeker -SQDC .

Deze opdracht zorgt ervoor dat elke hit een enkele regel rapporteert, wat veel gemakkelijker is voor tools
hendel. De stille en alleen data-opties verwijderen de andere statusinformatie die niet nodig is
gebruik binnenkant emacs. De volgperiode betekent dat de huidige map en alles
afstammelingen worden doorzocht op C/C++-code en geanalyseerd op gebreken.

Als je eenmaal de foutzoeker hebt aangeroepen, kun je emacs gebruiken om in de resultaten rond te springen. De
commando Cx ` (Control-x backtick) bezoekt de broncodelocatie voor de volgende waarschuwing
bericht. Cu Cx ` (control-u control-x backtick) begint opnieuw vanaf het begin. Jij kan
bezoek de bron voor een bepaald foutbericht door naar dat hitbericht in de
*compilatie* buffer of *grep* buffer en typ de return-toets. (Technische opmerking: in de
compilatiebuffer, dit roept de compile-goto-fout op.) U kunt ook op de muis-2 klikken
knop op de foutmelding (u hoeft niet eerst naar de *compilatie*-buffer over te schakelen).

Als je de grep-modus wilt gebruiken om naar specifieke kolommen van een treffer te springen, moet je dat doen
configureer speciaal emacs om dit te doen. Wijzig hiervoor de emacs-variabele "grep-regexp-
alist". Deze variabele vertelt Emacs hoe de uitvoer van een "grep"-opdracht moet worden geparseerd, vergelijkbaar met de
variabele "compilation-error-regexp-alist" die verschillende indelingen van compilatiefouten opsomt
berichten.

Het aanroepen oppompen van geïntegreerde Ontwikkeling omgevingen (Ides)
Raadpleeg voor (andere) IDE's de plug-ins van uw IDE.

GEMEENSCHAPPELIJKE ZWAKHEID OPSOMMING (CWE)

De Common Weakness Enumeration (CWE) is `` een formele lijst of woordenboek van algemene software
zwakke punten die kunnen optreden in de architectuur, het ontwerp, de code of de implementatie van software
kan leiden tot exploiteerbare beveiligingsproblemen... gemaakt om als gemeenschappelijke taal te dienen
voor het beschrijven van zwakheden in de softwarebeveiliging'' (http://cwe.mitre.org/about/faq.html). Voor
meer informatie over CWE's, zie http://cwe.mitre.org.

Flawfinder ondersteunt de CWE en is officieel CWE-compatibel. Hit beschrijvingen meestal
voeg een relevante Common Weakness Enumeration (CWE)-identificatiecode toe tussen haakjes waar die er is
staat bekend als een relevante CWE. Zo worden veel van de buffergerelateerde treffers genoemd
CWE-120, de CWE-identificatie voor ``bufferkopie zonder controle van de invoergrootte'' (aka
``Klassieke bufferoverloop''). In enkele gevallen kan meer dan één CWE-identificatiecode worden vermeld.
Het HTML-rapport bevat ook hyperlinks naar de CWE-definities die bij MITRE worden gehost. In
op deze manier is de foutzoeker ontworpen om te voldoen aan de CWE-Output-vereiste.

Veel van de door faultfinder gerapporteerde CWE's zijn geïdentificeerd in de CWE/SANS top 25 lijst 2011
(http://cwe.mitre.org/top25/). Veel mensen zullen in deze lijst naar CWE's willen zoeken,
zoals CWE-120 (klassieke bufferoverloop), wanneer de foutzoeker wordt toegewezen aan een CWE, is dat meer
algemeen dan een item uit de top 25, wordt het vermeld als meer-algemeen:meer-specifiek (bijv.
CWE-119:CWE-120), waar meer algemeen de eigenlijke mapping is. Als faultfinder wordt toegewezen aan een more
specifiek CWE-item dat een specifiek geval is van een top 25-item, wordt vermeld in het formulier
top-25/meer-specifiek (bijv. CWE-362/CWE-367), waarbij de echte mapping specifieker is
CWE-invoer. Als hetzelfde item wordt toegewezen aan meerdere CWE's, worden de CWE's gescheiden door komma's
(dit komt vaak voor bij CWE-20, Onjuiste invoervalidatie). Dit vereenvoudigt het zoeken naar
bepaalde CWE's.

CWE versie 2.7 (uitgebracht op 23 juni 2014) werd gebruikt voor het in kaart brengen. De huidige CWE
mappings selecteren de meest specifieke CWE die de tool kan bepalen. In theorie de meeste CWE
beveiligingselementen (handtekeningen/patronen waarnaar de tool zoekt) theoretisch zouden kunnen zijn
toegewezen aan CWE-676 (gebruik van potentieel gevaarlijke functie), maar een dergelijke toewijzing zou niet
bruikbaar. Er werd dus de voorkeur gegeven aan meer specifieke mappings waar die te vinden waren. Foutzoeker
is een hulpmiddel voor lexicale analyse; als gevolg hiervan is het onpraktisch om specifieker te zijn dan
de toewijzingen die momenteel zijn geïmplementeerd. Dit betekent ook dat het onwaarschijnlijk is dat er veel nodig is
bijwerken voor kaartvaluta; het heeft simpelweg niet genoeg informatie om te verfijnen tot een
gedetailleerd CWE-niveau waarop CWE-wijzigingen doorgaans van invloed zouden zijn. De lijst met CWE-identificatiecodes
werd automatisch gegenereerd met behulp van "make show-cwes", dus er is vertrouwen dat deze lijst
is juist. Rapporteer CWE-mappingproblemen als bugs als u er een vindt.

Het is mogelijk dat Flawfinder een kwetsbaarheid niet vindt, zelfs als de foutzoeker een van deze CWE's dekt
zwakke punten. Dat gezegd hebbende, vindt de foutzoeker kwetsbaarheden die worden vermeld door de CWE's die het dekt,
en het zal in veel gevallen geen lijnen rapporteren zonder die kwetsbaarheden. Dus, als
vereist voor elke tool die CWE-compatibel wil zijn, heeft faultfinder een foutpercentage
positieven minder dan 100% en een percentage fout-negatieven van minder dan 100%. Foutzoeker bijna
rapporteert altijd wanneer het een match vindt met een CWE-beveiligingselement (een handtekening/patroon als
gedefinieerd in zijn database), hoewel bepaalde onduidelijke constructies ervoor kunnen zorgen dat het mislukt (zie BUGS
hieronder).

Flawfinder kan rapporteren over de volgende CWE's (dit zijn de CWE's die door faultfinder worden gedekt;
``*'' markeert degenen in de CWE/SANS top 25 lijst):

· CWE-20: Onjuiste invoervalidatie

· CWE-22: Onjuiste beperking van een padnaam tot een beperkte map (``Path Traversal'')

· CWE-78: Onjuiste neutralisatie van speciale elementen die worden gebruikt in een OS-opdracht (``OS Command
Injectie'')*

· CWE-119: Onjuiste beperking van bewerkingen binnen de grenzen van een geheugenbuffer (een
ouder van CWE-120*, dus dit wordt weergegeven als CWE-119:CWE-120)

· CWE-120: Bufferkopie zonder controle van invoergrootte (``Classic Buffer Overflow'')*

· CWE-126: Buffer overlezen

· CWE-134: Ongecontroleerde tekenreeks*

· CWE-190: Integer Overflow of Wraparound*

· CWE-250: uitvoering met onnodige privileges

· CWE-327: Gebruik van een defect of riskant cryptografisch algoritme*

· CWE-362: Gelijktijdige uitvoering met behulp van gedeelde bron met onjuiste synchronisatie
(``Raceconditie'')

· CWE-377: onveilig tijdelijk bestand

· CWE-676: Gebruik van potentieel gevaarlijke functie*

· CWE-732: Onjuiste machtigingstoewijzing voor kritieke bron*

· CWE-785: gebruik van padmanipulatiefunctie zonder buffer van maximale grootte (kind van
CWE-120*, dus dit wordt weergegeven als CWE-120/CWE-785)

· CWE-807: vertrouwen op niet-vertrouwde invoer in een beveiligingsbeslissing*

· CWE-829: opname van functionaliteit van niet-vertrouwde controlesfeer*

U kunt een specifieke subset van CWE's selecteren om te rapporteren door de optie ``--regex'' (-e) te gebruiken.
Deze optie accepteert een reguliere expressie, dus u kunt meerdere CWE's selecteren, bijvoorbeeld ``--regex
"CWE-120|CWE-126"''. Als u meerdere CWE's selecteert met ``|'' op een opdrachtregel, dan doet u dat
meestal moeten de parameters worden aangehaald (aangezien een niet-aangehaald ``|'' het pipe-symbool is).
Flawfinder is ontworpen om te voldoen aan de CWE-Searchable-vereiste.

Als het uw doel is om een ​​subset van CWE's te rapporteren die in een bestand worden vermeld, kan dat worden bereikt
op een Unix-achtig systeem met behulp van de optie ``--regex'' oftewel ``-e''. Het bestand moet binnen zijn
formaat voor reguliere expressies. ``flawfinder -e $(cat file1)'' zou bijvoorbeeld alleen rapporteren
hits die overeenkomen met het patroon in ``file1''. Als bestand1 ``CWE-120|CWE-126'' bevatte, zou het
zou alleen treffers rapporteren die overeenkomen met die CWE's.

Een lijst met alle CWE-beveiligingselementen (de handtekeningen/patronen waarnaar de foutzoeker zoekt)
kan worden gevonden door de optie ``--listrules'' te gebruiken. Op elke regel staat het handtekeningtoken
(meestal een functienaam) die kan leiden tot een treffer, het standaard risiconiveau en de
standaardwaarschuwing (inclusief de standaard CWE-ID). Voor de meeste doeleinden is dit
ook genoeg als u wilt zien welke CWE-beveiligingselementen verwijzen naar welke CWE's, of de
achteruit. Om bijvoorbeeld de meeste handtekeningen (functienamen) te zien die verwijzen naar
CWE-327, zonder het standaard risiconiveau of gedetailleerde waarschuwingstekst te zien, voer ``flawfinder
--lijstregels | grep CWE-327 | knippen -f1''. U kunt de tokens ook zonder CWE-mapping zien
op deze manier door ``flawfinder -D --listrules | uit te voeren grep -v CWE-''. Hoewel, terwijl
--listrules somt alle CWE-beveiligingselementen op, het vermeldt alleen de standaardtoewijzingen van CWE
beveiligingselementen naar CWE-identificatoren. Het omvat niet de verfijningen die foutzoeker
van toepassing is (bijvoorbeeld door functieparameters te onderzoeken).

Als u een gedetailleerde en exacte mapping wilt tussen de CWE-beveiligingselementen en CWE
identifiers, is de broncode van de foutzoeker (inbegrepen in de distributie) de beste plaats
voor die informatie. Deze gedetailleerde informatie is vooral van belang voor die weinigen
mensen die proberen de CWE-toewijzingen van faultfinder te verfijnen of CWE in het algemeen te verfijnen.
De broncode documenteert de mapping tussen de beveiligingselementen naar de respectievelijke CWE
identifiers, en is een enkel Python-bestand. De dataset ``c_rules'' definieert de meeste regels,
met verwijzing naar een functie die verdere verfijningen kan aanbrengen. U kunt zoeken op de
dataset voor functienamen om te zien wat CWE standaard genereert; als de eerste parameter is
niet ``normaal'', dan is dat de naam van een verfijnde Python-methode die anders kan selecteren
CWE's (afhankelijk van aanvullende informatie). Omgekeerd kunt u zoeken op ``CWE-nummer''
en zoek welke beveiligingselementen (handtekeningen of patronen) naar die CWE-identificatiecode verwijzen.
Voor de meeste mensen is dit veel meer dan ze nodig hebben; de meeste mensen willen gewoon hun
broncode om snel problemen te vinden.

VEILIGHEID

Het hele doel van deze tool is om kwetsbaarheden te helpen vinden, zodat ze kunnen worden verholpen.
Ontwikkelaars en recensenten moeten echter weten hoe ze veilige software moeten ontwikkelen om dit te gebruiken
hulpmiddel, omdat anders a voor de gek houden Met a tools is nog a voor de gek houden. Mijn boek op
http://www.dwheeler.com/secure-programs kan helpen.

Deze tool zou hoogstens een klein onderdeel moeten zijn van een groter softwareontwikkelingsproces
ontworpen om de impact van kwetsbaarheden te elimineren of te verminderen. Ontwikkelaars en recensenten
moeten weten hoe ze veilige software moeten ontwikkelen, en ze moeten deze kennis toepassen om te verminderen
de risico's van kwetsbaarheden in de eerste plaats.

Verschillende tools voor het opsporen van kwetsbaarheden hebben de neiging om verschillende kwetsbaarheden te vinden. Dus jij
zijn het beste af met menselijke beoordeling en een verscheidenheid aan tools. Deze tool kan helpen bij het vinden van een aantal
kwetsbaarheden, maar lang niet allemaal.

Je moet altijd a analyseren kopiëren van het bronprogramma dat wordt geanalyseerd, niet een map
die kan worden aangepast door een ontwikkelaar terwijl de foutzoeker de analyse uitvoert. Dit is
vooral waar als u een ontwikkelaar van het programma dat wordt geanalyseerd niet noodzakelijkerwijs vertrouwt.
Als een aanvaller controle heeft over de bestanden terwijl u ze analyseert, kan de aanvaller dat wel
verplaats bestanden of wijzig hun inhoud om te voorkomen dat een beveiligingsprobleem aan het licht komt
(of de indruk wekken van een probleem dat er niet is). Als je je zorgen maakt over
kwaadwillende programmeurs moet u dit sowieso doen, want na analyse moet u dit doen
controleer of de code die uiteindelijk wordt uitgevoerd de code is die u hebt geanalyseerd. Gebruik ook niet de
--allowlink-optie in dergelijke gevallen; aanvallers kunnen kwaadaardige symbolische koppelingen naar bestanden maken
buiten hun broncodegebied (zoals / Etc / passwd).

Broncodebeheersystemen (zoals SourceForge en Savannah) vallen hier zeker onder
categorie; als u een van die systemen onderhoudt, kopieert of extraheert u eerst de bestanden naar
een aparte map (die niet kan worden beheerd door aanvallers) voordat u de foutzoeker uitvoert of
elke andere code-analysetool.

Merk op dat faultfinder alleen gewone bestanden, mappen en (indien gevraagd) symbolische bestanden opent
koppelingen; het zal nooit andere soorten bestanden openen, zelfs niet als er een symbolische link naar gemaakt is.
Dit gaat aanvallers tegen die ongebruikelijke bestandstypen in de broncode invoegen. Dit echter
werkt alleen als het bestandssysteem dat wordt geanalyseerd niet kan worden gewijzigd door een aanvaller tijdens de
analyse, zoals hierboven aanbevolen. Deze bescherming werkt ook niet op Cygwin-platforms,
helaas.

Cygwin-systemen (Unix-emulatie bovenop Windows) hebben een bijkomend probleem als foutzoeker
wordt gebruikt om programma's te analyseren die de analist niet kan vertrouwen. Het probleem is te wijten aan een ontwerp
fout in Windows (die het erft van MS-DOS). Op Windows en MS-DOS, bepaalde bestandsnamen
(bijv. ``com1'') worden door het besturingssysteem automatisch behandeld als de namen van
randapparatuur, en dit geldt zelfs wanneer een volledige padnaam wordt gegeven. Ja, Windows en MS-DOS
zijn echt zo slecht ontworpen. Flawfinder lost dit op door te controleren wat een bestandssysteem
object is, en dan alleen mappen en reguliere bestanden openen (en symlinks indien ingeschakeld).
Helaas werkt dit niet op Cygwin; op ten minste sommige versies van Cygwin op sommige
versies van Windows, alleen al proberen te bepalen of een bestand een apparaattype is, kan de
programma te hangen. Een tijdelijke oplossing is het verwijderen of hernoemen van bestandsnamen die worden geïnterpreteerd
als apparaatnamen voordat u de analyse uitvoert. Deze zogenaamde ``gereserveerde namen'' zijn
CON, PRN, AUX, CLOCK$, NUL, COM1-COM9 en LPT1-LPT9, eventueel gevolgd door een extensie
(bijv. ``com1.txt''), in elke map en in elk geval (Windows is niet hoofdlettergevoelig).

Do niet laad of diff hitlijsten van niet-vertrouwde bronnen. Ze worden uitgevoerd met behulp van de
Python-augurkmodule en de augurkmodule is niet bedoeld als beveiliging tegen fouten
of kwaadwillig geconstrueerde gegevens. Opgeslagen hitlijsten zijn bedoeld voor later gebruik door dezelfde
gebruiker die de hitlijst heeft gemaakt; in dat kader is deze beperking geen probleem.

Gebruik de online foutzoeker met behulp van onworks.net-services