flawfinder - Online sa Cloud

PROGRAMA:

NAME

flawfinder - lexically mahanap ang mga potensyal na bahid ng seguridad ("hit") sa source code

SINOPSIS

flawfinder [- Tumulong|-h] [--bersyon] [--listrules]
[--allowlink] [--followdotdir] [--nolink]
[--patch=filename|-P filename]
[--mga input|-I] [ --minlevel=X | -m X ] [--falsepositive|-F]
[--huwag pansinin|-n]
[--regex=PATTERN | -e PATTERN]
[--konteksto|-c] [--mga hanay|-C] [--dataonly|-D] [--html|-H] [--agad|-i]
[--isang linya|-S] [--omittime] [--tahimik|-Q]
[--loadhitlist=F] [--savehitlist=F] [--diffhitlist=F]
[--] [ pinagmulan code file or pinagmulan ugat direktoryo ]+

DESCRIPTION

Ang Flawfinder ay naghahanap sa pamamagitan ng C/C++ source code na naghahanap ng mga potensyal na bahid sa seguridad. Upang
magpatakbo ng flawfinder, bigyan lang ang flawfinder ng listahan ng mga direktoryo o file. Para sa bawat direktoryo
ibinigay, lahat ng mga file na may mga extension ng C/C++ filename sa direktoryo na iyon (at ang
subdirectory, recursively) ay susuriin. Kaya, para sa karamihan ng mga proyekto, magbigay lang
flawfinder ang pangalan ng pinakamataas na direktoryo ng source code (gamitin ang ``.'' para sa kasalukuyang
directory), at susuriin ng flawfinder ang lahat ng C/C++ source code ng proyekto. kung ikaw
gusto lang magkaroon mga pagbabago nirepaso, mag-save ng pinag-isang diff ng mga pagbabagong iyon (nilikha ng GNU
"diff -u" o "svn diff" o "git diff") sa isang patch file at gamitin ang --patch (-P) na opsyon.

Ang Flawfinder ay gagawa ng isang listahan ng mga ``hit'' (mga potensyal na bahid sa seguridad), na pinagsunod-sunod ayon sa panganib; ang
unang ipinapakita ang mga pinakamapanganib na hit. Ang antas ng panganib ay ipinapakita sa loob ng mga square bracket at nag-iiba-iba
mula 0, napakaliit na panganib, hanggang 5, malaking panganib. Ang antas ng panganib na ito ay nakasalalay hindi lamang sa
function, ngunit sa mga halaga ng mga parameter ng function. Halimbawa, pare-pareho
ang mga string ay kadalasang hindi gaanong mapanganib kaysa sa ganap na variable na mga string sa maraming konteksto, at sa mga iyon
konteksto ang hit ay magkakaroon ng mas mababang antas ng panganib. Alam ng Flawfinder ang tungkol sa gettext (isang karaniwang
library para sa mga internasyonal na programa) at ituturing ang patuloy na mga string na dumaan
gettext na parang pare-pareho silang mga string; binabawasan nito ang bilang ng mga maling hit
mga programang internasyonal. Gagawin ng Flawfinder ang parehong uri ng bagay sa _T() at
_TEXT(), karaniwang mga Microsoft macro para sa paghawak ng mga internasyonal na programa. Flawfinder
tama na binabalewala ang karamihan sa teksto sa loob ng mga komento at mga string. Karaniwang ipinapakita ng flawfinder ang lahat
mga hit na may antas ng panganib na hindi bababa sa 1, ngunit maaari mong gamitin ang --minlevel na opsyon upang ipakita lamang
mga hit na may mas mataas na antas ng panganib kung gusto mo. Tandaan din ng mga paglalarawan ng hit ang nauugnay na Karaniwan
Weakness Enumeration (CWE) identifier(s) sa mga panaklong, gaya ng tinalakay sa ibaba. Flawfinder
ay opisyal na CWE-Compatible.

Hindi lahat ng hit ay talagang kahinaan sa seguridad, at hindi lahat ng kahinaan sa seguridad
ay kinakailangang matagpuan. Gayunpaman, ang flawfinder ay maaaring maging tulong sa paghahanap at pag-alis
mga kahinaan sa seguridad. Ang karaniwang paraan ng paggamit ng flawfinder ay ang paglapat muna ng flawfinder
isang set ng source code at suriin ang mga item na may pinakamataas na panganib. Pagkatapos, gamitin ang --inputs upang suriin
ang mga lokasyon ng input, at suriin upang matiyak na ang mga legal at ligtas na halaga ng pag-input lamang ang
tinanggap mula sa mga hindi pinagkakatiwalaang user.

Kapag na-audit mo na ang isang programa, maaari mong markahan ang mga linya ng source code na talagang maayos ngunit
magdulot ng mga huwad na babala upang hindi na magreklamo ang flawfinder tungkol sa kanila. Upang markahan ang a
linya upang mapigil ang mga babalang ito, maglagay ng espesyal na naka-format na komento alinman sa
ang parehong linya (pagkatapos ng source code) o lahat nang mag-isa sa nakaraang linya. Ang komento
dapat magkaroon ng isa sa dalawang sumusunod na format:

· // Flawfinder: huwag pansinin

· /* Flawfinder: huwag pansinin */

Para sa kapakanan ng pagiging tugma, maaari mong palitan ang "Flawfinder:" ng "ITS4:" o "RATS:" sa mga ito
espesyal na-format na mga komento. Dahil posibleng mali ang mga ganoong linya, maaari mong gamitin
ang --neverignore na opsyon, na nagiging sanhi ng flawfinder na hindi kailanman balewalain ang anumang linya kahit na ano
sabi ng mga direktiba ng komento (mas nakakalito, --neverignore ignores the ignores).

Gumagamit ang Flawfinder ng panloob na database na tinatawag na ``ruleset''; kinikilala ng ruleset
mga function na karaniwang sanhi ng mga bahid ng seguridad. Kasama sa karaniwang ruleset ang isang malaki
bilang ng iba't ibang potensyal na problema, kabilang ang parehong pangkalahatang isyu na maaaring makaapekto sa alinman
C/C++ program, pati na rin ang ilang partikular na katulad ng Unix at Windows function na
lalong may problema. Ang pagpipiliang --listrules ay nag-uulat ng listahan ng mga kasalukuyang panuntunan at
kanilang mga default na antas ng panganib. Gaya ng nabanggit sa itaas, ang bawat potensyal na kakulangan sa seguridad na makikita sa isang naibigay
source code file (tumutugma sa isang entry sa ruleset) ay tinatawag na ``hit,'' at ang set ng
Ang mga hit na makikita sa anumang partikular na pagpapatakbo ng programa ay tinatawag na ``hitlist.'' Hitlists
maaaring i-save (gamit ang --savehitlist), i-reload pabalik para sa muling pagpapakita (gamit ang --loadhitlist), at
maaari mo lamang ipakita ang mga hit na naiiba sa isa pang run (gamit ang --diffhitlist).

Ang Flawfinder ay isang simpleng tool, na humahantong sa ilang pangunahing kalamangan at kahinaan. Gumagana ang Flawfinder
sa pamamagitan ng paggawa ng simpleng lexical tokenization (paglaktaw ng mga komento at wastong pag-token ng mga string),
naghahanap ng mga token na tugma sa database (lalo na upang makahanap ng mga function na tawag).
Ang Flawfinder ay katulad ng RATS at ITS4, na gumagamit din ng simpleng lexical tokenization.
Pagkatapos ay sinusuri ng Flawfinder ang teksto ng mga parameter ng function upang matantya ang panganib. Unlike
mga tool tulad ng splint, mga flag ng babala ng gcc, at clang, ginagawa ng flawfinder hindi gamitin o mayroon
access sa impormasyon tungkol sa daloy ng kontrol, daloy ng data, o mga uri ng data kapag naghahanap ng
mga potensyal na kahinaan o pagtantya sa antas ng panganib. Kaya, gagawin ng flawfinder
kinakailangang makagawa ng maraming maling positibo para sa mga kahinaan at hindi makapag-ulat ng marami
mga kahinaan. Sa kabilang banda, ang flawfinder ay makakahanap ng mga kahinaan sa mga program na iyon
hindi maaaring itayo o hindi maiugnay. Madalas itong gumana sa mga programa na hindi maaaring maging
pinagsama-sama (hindi bababa sa mga tool ng tagasuri). Hindi rin nalilito si Flawfinder
mga macro na kahulugan at iba pang mga kakaibang problema sa mas sopistikadong mga tool.
Ang Flawfinder ay maaari ding maging kapaki-pakinabang bilang isang simpleng panimula sa mga static na tool sa pagsusuri sa
pangkalahatan, dahil madaling simulan ang paggamit at madaling maunawaan.

Ang anumang filename na ibinigay sa command line ay susuriin (kahit na wala itong usual
C/C++ filename extension); kaya maaari mong pilitin ang flawfinder na suriin ang anumang partikular na mga file sa iyo
pagnanasa. Habang naghahanap ng mga direktoryo nang paulit-ulit, nagbubukas at nagsusuri lamang ang flawfinder
mga regular na file na may mga extension ng C/C++ filename. Ipinapalagay ng Flawfinder na ang mga file ay
C/C++ file kung mayroon silang mga extension na ".c", ".h", ".ec", ".ecp", ".pgc", ".C", ".cpp",
".CPP", ".cxx", ".cc", ".CC", ".pcc", ".hpp", o ".H". Ang filename na ``-'' ay nangangahulugang ang
karaniwang input. Upang maiwasan ang mga problema sa seguridad, mga espesyal na file (tulad ng mga espesyal na file ng device
at pinangalanang mga tubo) ay palaging nilaktawan, at bilang default ay nilaktawan ang mga simbolikong link (ang
--allowlink na opsyon ay sumusunod sa mga simbolikong link).

Pagkatapos ng listahan ng mga hit ay isang maikling buod ng mga resulta (gamitin ang -D upang alisin ito
impormasyon). Ipapakita nito ang bilang ng mga hit, mga linyang nasuri (tulad ng iniulat ng wc -l), at
nasuri ang pisikal na source lines of code (SLOC). Ang pisikal na SLOC ay isang hindi blangko, hindi-
linya ng komento. Pagkatapos ay ipapakita nito ang bilang ng mga hit sa bawat antas; tandaan na magkakaroon
hindi kailanman magiging hit sa antas na mas mababa sa minlevel (1 bilang default). Kaya, "[0] 0 [1] 9"
nangangahulugan na sa antas 0 mayroong 0 hit na iniulat, at sa antas 1 mayroong 9 na hit
iniulat. Susunod na ipapakita nito ang bilang ng mga hit sa isang partikular na antas o mas malaki (kaya antas 3+
may kabuuan ng bilang ng mga hit sa antas 3, 4, at 5). Kaya, isang entry ng "[0+] 37"
ay nagpapakita na sa antas 0 o mas mataas ay mayroong 37 hit (ang 0+ na entry ay palaging magiging pareho
bilang ang "hit" na numero sa itaas). Ang mga hit sa bawat KSLOC ay susunod na ipapakita; ito ang bawat isa sa "level o
mas mataas" na mga value na pinarami ng 1000 at hinati sa pisikal na SLOC. Kung ang mga symlink ay
nilaktawan, iniulat ang bilang ng mga iyon. Kung pinigilan ang mga hit (gamit ang "ignore"
direktiba sa mga komento ng source code tulad ng inilarawan sa itaas), ang numerong pinigilan ay iniulat.
Ang pinakamababang antas ng panganib na isasama sa ulat ay ipinapakita; bilang default ito ay 1
(gamitin ang --minlevel upang baguhin ito). Nagtatapos ang buod sa mahahalagang paalala: Hindi lahat ng hit
ay kinakailangang isang kahinaan sa seguridad, at maaaring may iba pang mga kahinaan sa seguridad
hindi iniulat ng tool.

Inilabas ang Flawfinder sa ilalim ng bersyon 2 ng lisensya ng GNU GPL o mas bago (GPLv2+).

Ang Flawfinder ay gumagana nang katulad sa isa pang programa, ang ITS4, na hindi ganap na open source
software (tulad ng tinukoy sa Open Source Definition) o libreng software (tulad ng tinukoy ng
Libreng Software Foundation). Hindi pa nakita ng may-akda ng Flawfinder ang source code ng ITS4.

MABILIS PAGTUTURO

Narito ang isang maikling halimbawa kung paano maaaring gamitin ang flawfinder. Isipin na mayroon kang C/C++
source code para sa ilang program na pinangalanang xyzzy (na maaaring isinulat mo o hindi), at
naghahanap ka ng mga kahinaan sa seguridad (upang maayos mo ang mga ito sa harap ng mga customer
makatagpo ng mga kahinaan). Para sa tutorial na ito, ipagpalagay ko na gumagamit ka ng Unix-
tulad ng system, gaya ng Linux, OpenBSD, o MacOS X.

Kung ang source code ay nasa isang subdirectory na pinangalanang xyzzy, malamang na magsisimula ka sa pamamagitan ng pagbubukas ng a
text window at gamit ang mga default na setting ng flawfinder, upang pag-aralan ang programa at mag-ulat a
priyoridad na listahan ng mga potensyal na kahinaan sa seguridad (tinitiyak lamang ng ``mas mababa'' ang
nananatili sa screen ang mga resulta):
flawfinder xyzzy | mas kaunti

Sa puntong ito, makikita mo ang isang malaking bilang ng mga entry. Ang bawat entry ay may filename, a
colon, isang numero ng linya, isang antas ng panganib sa mga bracket (kung saan ang 5 ay ang pinaka-peligro), isang kategorya,
ang pangalan ng function, at isang paglalarawan kung bakit iniisip ng flawfinder na ang linya ay a
kahinaan. Karaniwang nag-uuri ang Flawfinder ayon sa antas ng panganib, na nagpapakita muna ng mga pinakamapanganib na item;
kung mayroon kang limitadong oras, malamang na pinakamahusay na magsimulang magtrabaho sa mga pinaka-peligrong bagay at
magpatuloy hanggang sa maubusan ka ng oras. Kung gusto mong limitahan ang display sa mga panganib na may lamang a
ilang antas ng panganib o mas mataas, gamitin ang --minlevel na opsyon. Kung nakakakuha ka ng isang
hindi pangkaraniwang bilang ng mga maling positibo dahil ang mga variable na pangalan ay mukhang mapanganib
mga pangalan ng function, gamitin ang -F na opsyon upang alisin ang mga ulat tungkol sa kanila. Kung hindi mo maintindihan
ang mensahe ng error, mangyaring tingnan ang mga dokumento tulad ng Pagsulat Hindi makatatakas Programa para Linux at
Unix PAANO ⟨http://www.dwheeler.com/secure-programs⟩ sa http://www.dwheeler.com/secure-
mga programang nagbibigay ng higit pang impormasyon sa pagsulat ng mga secure na programa.

Sa sandaling matukoy mo ang problema at maunawaan ito, maaari mo itong ayusin. Paminsan-minsan maaari mong
nais na muling gawin ang pagsusuri, pareho dahil magbabago ang mga numero ng linya at upang matiyak
na ang bagong code ay hindi pa nagpapakilala ng ibang kahinaan.

Kung natukoy mo na ang ilang linya ay hindi talaga isang problema, at sigurado ka dito, magagawa mo
magsingit lang bago o sa offending line ng komentong gusto
/* Flawfinder: huwag pansinin */
para hindi sila lumabas sa output.

Kapag nagawa mo na iyon, dapat kang bumalik at maghanap para sa mga input ng programa, upang gawin
tiyaking sinasala ng program ang alinman sa mga hindi pinagkakatiwalaang input nito. Pwede ang Flawfinder
kilalanin ang maraming mga input ng programa sa pamamagitan ng paggamit ng --inputs na opsyon, tulad nito:
flawfinder --naglalagay ng xyzzy

Ang Flawfinder ay maaaring maisama nang maayos sa mga text editor at pinagsama-samang mga kapaligiran sa pag-unlad;
tingnan ang mga halimbawa para sa karagdagang impormasyon.

Kasama sa Flawfinder ang maraming iba pang mga opsyon, kabilang ang mga para gumawa ng mga HTML na bersyon ng
output (kapaki-pakinabang para sa mas magagandang pagpapakita). Ang susunod na seksyon ay naglalarawan sa mga opsyon na iyon sa higit pa
detalye.

Opsyon

Ang Flawfinder ay may ilang mga opsyon, na maaaring i-grupo sa mga opsyon na kumokontrol sa sarili nito
dokumentasyon, piliin ang data ng input, piliin kung aling mga hit ang ipapakita, piliin ang format ng output,
at magsagawa ng pamamahala ng hitlist. Sinusuportahan ng Flawfinder ang karaniwang syntax na tinukoy sa
POSIX (Isyu 7, 2013 Edition) na seksyong ``Mga Utility Convention''. Sinusuportahan din nito ang GNU
mahabang opsyon (double-dash na mga opsyon ng form --opsyon) gaya ng tinukoy sa GNU C Aklatan
Sanggunian manwal ``Program Argument Syntax Conventions'' at GNU coding Pamantayan
``Mga Pamantayan para sa Mga Interface ng Command Line''. Ang mga argumento ng mahabang opsyon ay maaaring ibigay bilang
``--name=value'' o ``-name value''. Maa-access lang ang ilang opsyon gamit ang higit pa
nababasa GNU long option convention; ang mga karaniwang opsyon ay sinusuportahan din ng mas matanda
solong-titik na kumbensyon ng opsyon.

dokumentasyon
- Tumulong

-h Ipakita ang impormasyon sa paggamit (tulong).

--bersyon Ipinapakita (lang) ang numero ng bersyon at paglabas.

--listrules Ilista ang mga termino (token) na nagpapalitaw ng karagdagang pagsusuri, ang kanilang default na panganib
level, at ang default na babala (kabilang ang (mga) identifier ng CWE, kung
naaangkop), lahat ng tab-separated. Ang mga termino ay pangunahing mga pangalan ng potensyal na-
mapanganib na mga pag-andar. Tandaan na ang iniulat na antas ng panganib at babala para sa ilan
maaaring iba ang partikular na code kaysa sa default, depende sa kung paano ang termino
ginamit. Pagsamahin sa -D kung hindi mo gusto ang karaniwang header. Flawfinder
binago ng bersyon 1.29 ang separator mula sa mga puwang patungo sa mga tab, at idinagdag ang default
field ng babala.

Ang pagpili input data
--allowlink Payagan ang paggamit ng mga simbolikong link; karaniwang nilaktawan ang mga simbolikong link. huwag
gamitin ang opsyong ito kung sinusuri mo ang code ng iba; maraming magagawa ang mga umaatake
mga bagay na magdulot ng mga problema para sa isang pagsusuri na pinagana ang opsyong ito. Para sa
halimbawa, ang isang umaatake ay maaaring magpasok ng mga simbolikong link sa mga file gaya ng / etc / passwd
(naglalabas ng impormasyon tungkol sa file) o lumikha ng isang pabilog na loop, na gagawin
maging sanhi ng flawfinder na tumakbo ``magpakailanman''. Isa pang problema sa pagpapagana nito
Ang pagpipilian ay kung ang parehong file ay isinangguni nang maraming beses gamit ang symbolic
mga link, ito ay susuriin ng maraming beses (at sa gayon ay iuulat nang maraming beses).
Tandaan na kasama na ng flawfinder ang ilang proteksyon laban sa mga simbolikong link
sa mga espesyal na uri ng file gaya ng mga uri ng file ng device (hal., /dev/zero o
C:\mystuff\com1). Tandaan na para sa flawfinder na bersyon 1.01 at dati, ito ay
ang default.

--followdotdir
Magpasok ng mga direktoryo na ang mga pangalan ay nagsisimula sa ".". Karaniwan ang mga naturang direktoryo ay
hindi pinansin, dahil karaniwang kasama sa mga ito ang pribadong data ng kontrol sa bersyon (tulad ng
.git/ o .svn/), mga configuration, at iba pa.

--nolink Hindi pinansin. Sa kasaysayan, hindi pinagana nito ang pagsunod sa mga simbolikong link; pag-uugaling ito
ay ngayon ang default.

--patch=patchfile

-P patchfile
Suriin ang mga napiling file o direktoryo, ngunit iulat lamang ang mga hit sa mga linyang iyon
ay idinagdag o binago ng ibinigay na patch file. Ang patch file ay dapat nasa a
kinikilalang pinag-isang diff format (hal., ang output ng GNU "diff -u old new",
"svn diff", o "git diff [commit]"). Ipinapalagay ng Flawfinder na mayroon ang patch
nailapat na sa mga file. Ang patch file ay maaari ding magsama ng mga pagbabago sa
hindi nauugnay na mga file (babalewalain lang ang mga ito). Ang mga numero ng linya na ibinigay sa
patch file ay ginagamit upang matukoy kung aling mga linya ang binago, kaya kung mayroon ka
binago ang mga file mula noong ginawa ang patch file, muling buuin ang patch file
una. Mag-ingat na ang mga pangalan ng file ng mga bagong file na ibinigay sa patch file
dapat eksaktong tumugma, kabilang ang upper/lower case, path prefix, at direktoryo
separator (\ vs. /). Tanging pinag-isang diff format ang tinatanggap (GNU diff, svn
diff, at git diff output ay okay); kung mayroon kang ibang format, muli
i-regenerate mo muna. Mga hit lang na nangyayari sa mga resultang binagong linya, o
kaagad sa itaas at ibaba ng mga ito, ay iniulat. Ang pagpipiliang ito ay nagpapahiwatig
--huwag pansinin.

Ang pagpili Hits sa display
--mga input

-I Ipakita lamang ang mga function na kumukuha ng data mula sa labas ng programa; ito rin ang nagtatakda
minlevel hanggang 0.

--minlevel=X

-m X Itakda ang minimum na antas ng panganib sa X para maisama sa hitlist. Ito ay maaaring mula sa 0 (``hindi
panganib'') hanggang 5 (``pinakamalaking panganib''); ang default ay 1.

--falsepositive

-F Huwag isama ang mga hit na malamang na mga maling positibo. Sa kasalukuyan, ang ibig sabihin nito
na ang mga pangalan ng function ay binabalewala kung hindi sila sinusundan ng "(", at iyon
ang mga deklarasyon ng mga array ng character ay hindi nabanggit. Kaya, kung gumamit ka ng variable
pinangalanang "access" sa lahat ng dako, aalisin nito ang mga sanggunian sa ordinaryong ito
variable. Hindi ito ang default, dahil pinapataas din nito ang posibilidad ng
nawawala ang mahahalagang hit; sa partikular, mga pangalan ng function sa #define clause at tawag
sa pamamagitan ng function pointers ay hindi nakuha.

--huwag pansinin

-n Huwag kailanman balewalain ang mga isyu sa seguridad, kahit na mayroon silang direktiba na ``ignore'' sa a
komento

--regexp=PATTERN

-e PATTERN
Iulat lamang ang mga hit na may text na tumutugma sa pattern ng regular na expression na PATTERN.
Halimbawa, upang mag-ulat lamang ng mga hit na naglalaman ng text na "CWE-120", gamitin ang ``--regex
CWE-120''. Ang mga pangalan ng flag ng opsyon na ito ay kapareho ng grep.

Ang pagpili Pagbubuhos format
--mga hanay

-C Ipakita ang numero ng column (pati na rin ang pangalan ng file at numero ng linya) ng bawat hit;
ipinapakita ito pagkatapos ng numero ng linya sa pamamagitan ng pagdaragdag ng tutuldok at numero ng hanay sa
ang linya (ang unang character sa isang linya ay column number 1). Ito ay kapaki-pakinabang
para sa mga editor na maaaring tumalon sa mga partikular na column, o para sa pagsasama sa iba
mga tool (gaya ng mga para sa karagdagang pag-filter ng mga maling positibo).

--konteksto

-c Ipakita ang konteksto, ibig sabihin, ang linyang may "hit"/potensyal na kapintasan. Bilang default ang
ang linya ay ipinapakita kaagad pagkatapos ng babala.

--dataonly

-D Huwag ipakita ang header at footer. Gamitin ito kasama ng --tahimik para makita lang
ang data mismo.

--html

-H I-format ang output bilang HTML sa halip na bilang simpleng text.

--agad

-i Kaagad na ipakita ang mga hit (huwag lamang maghintay hanggang sa dulo).

--isang linya

-S Ipakita bilang isang linya ng output ng text para sa bawat hit. Kapaki-pakinabang para sa pakikipag-ugnayan
gamit ang compilation tools.

--omittime Alisin ang impormasyon sa oras. Ito ay kapaki-pakinabang para sa mga pagsusuri ng regression ng flawfinder
mismo, upang ang output ay hindi mag-iba depende sa kung gaano katagal ang pagsusuri
tumatagal

--tahimik

-Q Huwag magpakita ng impormasyon sa katayuan (ibig sabihin, kung aling mga file ang sinusuri) habang
ang pagsusuri ay nangyayari.

Hitlist pamamahala
--savehitlist=F
I-save ang lahat ng resultang hit (ang "hitlist") sa F.

--loadhitlist=F
I-load ang hitlist mula sa F sa halip na pag-aralan ang mga source program. Babala: Gawin hindi
mag-load ng mga hitlist mula sa mga hindi pinagkakatiwalaang mapagkukunan (para sa mga kadahilanang pangseguridad).

--diffhitlist=F
Ipakita lamang ang mga hit (na-load o nasuri) na wala sa F. Malamang na nilikha ang F
dating gumagamit ng --savehitlist. Babala: Gawin hindi diff hitlists mula sa hindi pinagkakatiwalaan
mga mapagkukunan (para sa mga kadahilanang pangseguridad). Kung hindi ibinigay ang --loadhitlist na opsyon,
ipapakita nito ang mga hit sa nasuri na source code file na hindi
dati nang nakaimbak sa F. Kung ginamit kasama ng --loadhitlist, ipapakita nito ang
hit sa load hitlist hindi sa F. Ang pagkakaiba ng algorithm ay
konserbatibo; ang mga hit ay itinuturing lamang na ``pareho'' kung mayroon silang pareho
filename, numero ng linya, posisyon ng column, pangalan ng function, at antas ng panganib.

HALIMBAWA

Narito ang iba't ibang mga halimbawa kung paano mag-invoke ng flawfinder. Ang mga unang halimbawa ay nagpapakita ng iba't ibang
simpleng mga pagpipilian sa command-line. Ang Flawfinder ay idinisenyo upang gumana nang maayos sa mga text editor at
pinagsamang mga kapaligiran sa pag-unlad, kaya ang mga susunod na seksyon ay nagpapakita kung paano isama ang flawfinder
sa vim at emacs.

Simple linya ng utos pagpipilian
flawfinder /usr/src/linux-3.16
Suriin ang lahat ng mga C/C++ na file sa direktoryo /usr/src/linux-3.16 at lahat nito
mga subdirectory (recursively), na nag-uulat sa lahat ng nakitang hit. Bilang default
lalaktawan ng flawfinder ang mga simbolikong link at direktoryo na may mga pangalan na nagsisimula sa
isang tuldok.

flawfinder --minlevel=4 .
Suriin ang lahat ng mga C/C++ na file sa kasalukuyang direktoryo at mga subdirectory nito
(recursively); iulat lamang ang mga kahinaan sa antas 4 at pataas (ang dalawang pinakamataas
mga antas ng panganib).

flawfinder --mga input mydir
Suriin ang lahat ng C/C++ na file sa mydir at ang mga subdirectory nito (recursively), at
mag-ulat ng mga function na kumukuha ng mga input (upang matiyak mong sinasala ng mga ito ang
mga input nang naaangkop).

flawfinder --huwag pansinin mydir
Suriin ang lahat ng mga C/C++ na file sa mydir na direktoryo at mga subdirectory nito,
kabilang ang kahit na ang mga hit na minarkahan para sa hindi pagpansin sa mga komento ng code.

flawfinder -QD mydir
Suriin ang mydir at iulat lamang ang mga aktwal na resulta (inaalis ang header at
footer ng output). Ang form na ito ay kapaki-pakinabang kung ang output ay ipapasok sa pipe
iba pang mga tool para sa karagdagang pagsusuri. Ang -C (--column) at -S (--singleline)
Ang mga opsyon ay maaari ding maging kapaki-pakinabang kung ipi-pipe mo ang data sa iba pang mga tool.

flawfinder -QDSC mydir
Suriin ang mydir, nag-uulat lamang ng mga aktwal na resulta (walang header o footer). Bawat isa
iniuulat ang hit sa isang linya, at iniuulat ang mga numero ng column. Ito ay maaaring isang
kapaki-pakinabang na utos kung pinapakain mo ang output ng flawfinder sa iba pang mga tool.

flawfinder --tahimik --html --konteksto mydir > results.html
Suriin ang lahat ng mga C/C++ na file sa mydir na direktoryo at mga subdirectory nito, at
gumawa ng HTML formatted na bersyon ng mga resulta. Pamamahala ng source code
Ang mga system (gaya ng SourceForge at Savannah) ay maaaring gumamit ng command na tulad nito.

flawfinder --tahimik --savehitlist na-save.hits *.[ch]
Suriin ang lahat ng .c at .h na file sa kasalukuyang direktoryo. Huwag mag-ulat sa
katayuan ng pagproseso, at i-save ang resultang hitlist (ang hanay ng lahat ng mga hit) sa
na-save ang file.hits.

flawfinder --diffhitlist na-save.hits *.[ch]
Suriin ang lahat ng .c at .h na file sa kasalukuyang direktoryo, at ipakita ang anumang mga hit na iyon
ay wala pa sa file na naka-save.hits. Ito ay maaaring gamitin upang ipakita lamang ang
``bago'' mga kahinaan sa isang binagong programa, kung ginawa ang saved.hits mula sa
ang mas lumang bersyon ng program na sinusuri.

flawfinder --tagpi kamakailan.patch .
Suriin ang kasalukuyang direktoryo nang paulit-ulit, ngunit iulat lamang ang mga linyang iyon
binago o idinagdag sa na-apply na patchfile na pinangalanan kamakailan.patch.

flawfinder --regex "CWE-120|CWE-126" src /
Suriin ang direktoryo SRC recursively, ngunit iulat lamang ang mga hit kung saan ang CWE-120 o
Nalalapat ang CWE-126.

Pagsusumikap mula kalakasan
Ang text editor vim ay may kasamang mekanismong "quickfix" na gumagana nang maayos sa flawfinder, kaya
na maaari mong madaling tingnan ang mga mensahe ng babala at tumalon sa nauugnay na source code.

Una, kailangan mong i-invoke ang flawfinder upang lumikha ng isang listahan ng mga hit, at mayroong dalawang paraan
gawin ito. Ang unang paraan ay simulan muna ang flawfinder, at pagkatapos ay (gamit ang output nito) mag-invoke
vim. Ang pangalawang paraan ay ang magsimula (o magpatuloy sa pagtakbo) vim, at pagkatapos ay mag-invoke ng flawfinder
(karaniwan ay mula sa loob ng vim).

Para sa unang paraan, patakbuhin ang flawfinder at iimbak ang output nito sa ilang FLAWFILE (sabihin ang "flawfile"),
pagkatapos ay i-invoke ang vim gamit ang -q na opsyon nito, tulad nito: "vim -q flawfile". Ang pangalawang paraan
(pagsisimula ng flawfinder pagkatapos simulan ang vim) ay maaaring gawin ng maraming paraan. Ang isa ay ang mag-invoke
flawfinder gamit ang shell command, ":!flawfinder-command > FLAWFILE", pagkatapos ay sundan iyon ng
ang utos na ":cf FLAWFILE". Ang isa pang paraan ay ang pag-imbak ng flawfinder command sa iyong
makefile (bilang, sabihin nating, isang pseudocommand tulad ng "flaw"), at pagkatapos ay patakbuhin ang ":make flaw".

Sa lahat ng mga kasong ito kailangan mo ng utos para tumakbo ang flawfinder. Isang makatwirang utos, na
inilalagay ang bawat hit sa sarili nitong linya (-S) at inaalis ang mga header at footer na makakalilito
ito ay:

flawfinder -SQD .

Maaari ka na ngayong gumamit ng iba't ibang mga utos sa pag-edit upang tingnan ang mga resulta. Ang command na ":cn" ay ipinapakita
ang susunod na hit; ":cN" ay nagpapakita ng nakaraang hit, at ":cr" rewind pabalik sa unang hit.
Ang ":copen" ay magbubukas ng isang window upang ipakita ang kasalukuyang listahan ng mga hit, na tinatawag na "quickfix
window"; ":cclose" ay isasara ang quickfix window. Kung ang buffer sa ginamit na window ay may
nagbago, at ang error ay nasa ibang file, ang paglukso sa error ay mabibigo. Kailangan mo
siguraduhin na ang window ay naglalaman ng isang buffer na maaaring iwanan bago subukang tumalon sa a
bagong file, sabihin sa pamamagitan ng pag-save ng file; pinipigilan nito ang hindi sinasadyang pagkawala ng data.

Pagsusumikap mula emacs
Kasama sa text editor / operating system emacs ang "grep mode" at "compile mode"
mga mekanismo na gumagana nang maayos sa flawfinder, na ginagawang madali upang tingnan ang mga mensahe ng babala, tumalon
sa nauugnay na source code, at ayusin ang anumang mga problemang makikita mo.

Una, kailangan mong mag-invoke ng flawfinder para gumawa ng listahan ng mga mensahe ng babala. Pwede mong gamitin
"grep mode" o "compile mode" para gawin ang listahang ito. Kadalasan ang "grep mode" ay mas maginhawa;
nag-iiwan ito ng compile mode na hindi nagalaw upang madali mong ma-recompile kapag nagbago ka na
isang bagay. Gayunpaman, kung gusto mong tumalon sa eksaktong posisyon ng column ng isang hit, mag-compile
maaaring mas maginhawa ang mode dahil magagamit ng mga emac ang column output ng flawfinder sa
direktang tumalon sa tamang lokasyon nang walang anumang espesyal na configuration.

Upang gamitin ang grep mode, ilagay ang command na "Mx grep" at pagkatapos ay ilagay ang kinakailangang flawfinder
utos. Upang gamitin ang compile mode, ipasok ang command na "Mx compile" at ipasok ang kailangan
utos ng flawfinder. Isa itong meta-key command, kaya kakailanganin mong gamitin ang meta key para sa
iyong keyboard (ito ay karaniwang ang ESC key). Tulad ng lahat ng emacs command, kakailanganin mo
pindutin ang RETURN pagkatapos i-type ang "grep" o "compile". Kaya sa maraming mga sistema, ang grep mode ay
hinihingi sa pamamagitan ng pag-type ng ESC xgrep RETURN.

Pagkatapos ay kailangan mong magpasok ng isang utos, alisin ang anumang naroon noon kung kinakailangan. A
makatwirang utos ay:

flawfinder -SQDC .

Ginagawa ng command na ito ang bawat hit na ulat ng isang linya, na mas madaling gawin ng mga tool
hawakan. Ang tahimik at data lamang na mga pagpipilian ay nag-aalis ng iba pang impormasyon ng katayuan na hindi kailangan para sa
gamitin sa loob ng emacs. Ang trailing period ay nangangahulugan na ang kasalukuyang direktoryo at lahat
hinanap ang mga descendent para sa C/C++ code, at sinusuri kung may mga bahid.

Kapag na-invoke mo na ang flawfinder, maaari mong gamitin ang mga emac upang tumalon sa mga resulta nito. Ang
Ang command na Cx ` (Control-x backtick) ay bumibisita sa lokasyon ng source code para sa susunod na babala
mensahe. Ang Cu Cx ` (control-u control-x backtick) ay magsisimula mula sa simula. Kaya mo
bisitahin ang pinagmulan para sa anumang partikular na mensahe ng error sa pamamagitan ng paglipat sa hit na mensahe sa
*compilation* buffer o *grep* buffer at i-type ang return key. ( Teknikal na tala: sa
compilation buffer, ito ay humihimok ng compile-goto-error.) Maaari mo ring i-click ang Mouse-2
button sa mensahe ng error (hindi mo kailangang lumipat muna sa *compilation* buffer).

Kung gusto mong gumamit ng grep mode para tumalon sa mga partikular na column ng isang hit, kakailanganin mo
espesyal na i-configure ang mga emac para gawin ito. Upang gawin ito, baguhin ang emacs variable na "grep-regexp-
alist". Sinasabi ng variable na ito sa Emacs kung paano i-parse ang output ng isang command na "grep", katulad ng
variable na "compilation-error-regexp-alist" na naglilista ng iba't ibang format ng compilation error
mga mensahe.

Pagsusumikap mula Pinagsama Pag-unlad Mga kapaligiran (mga IDE)
Para sa (iba pang) IDE, kumonsulta sa hanay ng mga plug-in ng iyong IDE.

KARANIWANG KAHINAAN ENUMERATION (CWE)

Ang Common Weakness Enumeration (CWE) ay ``isang pormal na listahan o diksyunaryo ng karaniwang software
mga kahinaan na maaaring mangyari sa arkitektura, disenyo, code o pagpapatupad ng software na iyon
ay maaaring humantong sa mga mapagsamantalang kahinaan sa seguridad... nilikha upang magsilbi bilang isang karaniwang wika
para sa paglalarawan ng mga kahinaan sa seguridad ng software'' (http://cwe.mitre.org/about/faq.html). Para sa
higit pang impormasyon sa mga CWE, tingnan http://cwe.mitre.org.

Sinusuportahan ng Flawfinder ang CWE at opisyal na CWE-Compatible. Karaniwang mga paglalarawan ng hit
magsama ng nauugnay na Common Weakness Enumeration (CWE) identifier sa mga panaklong kung saan mayroong
ay kilala bilang isang nauugnay na CWE. Halimbawa, binanggit ang marami sa mga hit na nauugnay sa buffer
CWE-120, ang CWE identifier para sa ``buffer copy nang hindi sinusuri ang laki ng input'' (aka
``Classic Buffer Overflow''). Sa ilang mga kaso, higit sa isang CWE identifier ang maaaring nakalista.
Kasama rin sa ulat ng HTML ang mga hypertext na link sa mga kahulugan ng CWE na naka-host sa MITRE. Sa
sa ganitong paraan, idinisenyo ang flawfinder upang matugunan ang kinakailangan ng CWE-Output.

Marami sa mga CWE na iniulat ng flawfinder ay kinilala sa CWE/SANS top 25 list 2011
(http://cwe.mitre.org/top25/). Maraming tao ang gustong maghanap ng mga CWE sa listahang ito,
gaya ng CWE-120 (classic buffer overflow), Kapag nagmamapa ang flawfinder sa isang CWE na mas
pangkalahatan kaysa sa isang nangungunang 25 na item, inililista ito bilang mas pangkalahatan:mas tiyak (hal,
CWE-119:CWE-120), kung saan ang mas pangkalahatan ay ang aktwal na pagmamapa. Kung ang flawfinder ay nagmamapa sa isang higit pa
partikular na CWE item na isang partikular na kaso ng isang nangungunang 25 item, ito ay nakalista sa form
top-25/more-specific (hal., CWE-362/CWE-367), kung saan ang totoong pagmamapa ay mas tiyak
CWE entry. Kung ang parehong entry ay nagmamapa sa maraming CWE, ang mga CWE ay pinaghihiwalay ng mga kuwit
(ito ay madalas na nangyayari sa CWE-20, Hindi Tamang Pagpapatunay ng Input). Pinapasimple nito ang paghahanap
ilang mga CWE.

CWE bersyon 2.7 (inilabas noong Hunyo 23, 2014) ay ginamit para sa pagmamapa. Ang kasalukuyang CWE
piliin ng mga pagmamapa ang pinakaspesipikong CWE na matutukoy ng tool. Sa teorya, karamihan sa CWE
mga elemento ng seguridad (mga lagda/pattern na hinahanap ng tool) ayon sa teorya
nakamapa sa CWE-676 (Paggamit ng Potensyal na Mapanganib na Function), ngunit ang naturang pagmamapa ay hindi magiging
kapaki-pakinabang. Kaya, mas partikular na mga pagmamapa ang ginustong kung saan mahahanap ang isa. Flawfinder
ay isang lexical analysis tool; bilang isang resulta, ito ay hindi praktikal na ito ay mas tiyak kaysa sa
ang mga mapping na kasalukuyang ipinapatupad. Nangangahulugan din ito na malamang na hindi ito nangangailangan ng marami
pag-update para sa pera ng mapa; wala lang itong sapat na impormasyon upang pinuhin sa a
detalyadong antas ng CWE na karaniwang maaapektuhan ng mga pagbabago sa CWE. Ang listahan ng mga identifier ng CWE
ay awtomatikong nabuo gamit ang "make show-cwes", kaya may kumpiyansa na ang listahang ito
ay tama. Mangyaring iulat ang mga problema sa pagmamapa ng CWE bilang mga bug kung may makita ka.

Maaaring mabigo ang Flawfinder na makahanap ng kahinaan, kahit na saklaw ng flawfinder ang isa sa mga CWE na ito
mga kahinaan. Sabi nga, nakakahanap ang flawfinder ng mga kahinaan na nakalista ng mga CWE na sinasaklaw nito,
at hindi ito mag-uulat ng mga linya nang walang mga kahinaang iyon sa maraming kaso. Kaya, bilang
kinakailangan para sa anumang tool na naglalayong maging katugma sa CWE, may rate ng false ang flawfinder
mga positibong mas mababa sa 100% at isang rate ng mga maling negatibong mas mababa sa 100%. Flawfinder halos
palaging nag-uulat sa tuwing makakahanap ito ng katugma sa isang elemento ng seguridad ng CWE (isang lagda/pattern bilang
tinukoy sa database nito), kahit na ang ilang hindi malinaw na mga konstruksyon ay maaaring maging sanhi ng pagkabigo nito (tingnan ang BUGS
sa ibaba).

Maaaring mag-ulat ang Flawfinder sa mga sumusunod na CWE (ito ang mga CWE na saklaw ng flawfinder;
Ang ``*'' ay nagmamarka sa mga nasa listahan ng CWE/SANS top 25):

· CWE-20: Hindi Wastong Pagpapatunay ng Input

· CWE-22: Hindi Wastong Limitasyon ng isang Pathname sa isang Restricted Directory (``Path Traversal'')

· CWE-78: Hindi Wastong Neutralisasyon ng Mga Espesyal na Elemento na ginamit sa isang OS Command (``OS Command
Iniksyon'')*

· CWE-119: Hindi Wastong Paghihigpit ng mga Operasyon sa loob ng Hangganan ng isang Memory Buffer (a
magulang ng CWE-120*, kaya ipinapakita ito bilang CWE-119:CWE-120)

· CWE-120: Buffer Copy nang walang Sinusuri ang Sukat ng Input (``Classic Buffer Overflow'')*

· CWE-126: Buffer Over-read

· CWE-134: Hindi Nakontrol na String ng Format*

· CWE-190: Integer Overflow o Wraparound*

· CWE-250: Pagpapatupad na may Mga Hindi Kinakailangang Pribilehiyo

· CWE-327: Paggamit ng Sirang o Mapanganib na Cryptographic Algorithm*

· CWE-362: Kasabay na Pagpapatupad gamit ang Nakabahaging Resource na may Hindi Tamang Pag-synchronize
(``Kalagayan ng Lahi'')

· CWE-377: Hindi Secure na Pansamantalang File

· CWE-676: Paggamit ng Potensyal na Mapanganib na Function*

· CWE-732: Maling Pagtatalaga ng Pahintulot para sa Kritikal na Resource*

· CWE-785: Paggamit ng Path Manipulation Function na walang Maximum-sized na Buffer (anak ng
CWE-120*, kaya ipinapakita ito bilang CWE-120/CWE-785)

· CWE-807: Pag-asa sa Mga Hindi Pinagkakatiwalaang Input sa isang Desisyon sa Seguridad*

· CWE-829: Pagsasama ng Functionality mula sa Untrusted Control Sphere*

Maaari kang pumili ng partikular na subset ng mga CWE na iuulat sa pamamagitan ng paggamit ng opsyong ``--regex'' (-e).
Ang opsyong ito ay tumatanggap ng isang regular na expression, kaya maaari kang pumili ng maraming CWE, hal, ``--regex
"CWE-120|CWE-126"''. Kung pipili ka ng maraming CWE na may ``|'' sa isang command line ay gagawin mo
karaniwang kailangang banggitin ang mga parameter (dahil ang isang hindi naka-quote na ``|'' ay ang simbolo ng pipe).
Ang Flawfinder ay idinisenyo upang matugunan ang CWE-Searchable na kinakailangan.

Kung ang iyong layunin ay mag-ulat ng isang subset ng mga CWE na nakalista sa isang file, iyon ay maaaring makamit
sa isang Unix-like system gamit ang ``--regex'' aka ``-e'' na opsyon. Ang file ay dapat na nasa
format ng regular na expression. Halimbawa, ang ``flawfinder -e $(cat file1)'' ay mag-uulat lamang
mga hit na tumugma sa pattern sa ``file1''. Kung ang file1 ay naglalaman ng ``CWE-120|CWE-126'' ito
mag-uulat lamang ng mga hit na tumutugma sa mga CWE na iyon.

Isang listahan ng lahat ng elemento ng seguridad ng CWE (ang mga lagda/pattern na hinahanap ng flawfinder)
ay matatagpuan sa pamamagitan ng paggamit ng ``--listrules'' na opsyon. Ang bawat linya ay naglilista ng signature token
(karaniwang pangalan ng function) na maaaring humantong sa isang hit, ang default na antas ng panganib, at ang
default na babala (na kinabibilangan ng default na CWE identifier). Para sa karamihan ng mga layunin ito ay
sapat din kung gusto mong makita kung ano ang mapa ng mga elemento ng seguridad ng CWE kung aling mga CWE, o ang
baliktarin. Halimbawa, upang makita ang karamihan sa mga lagda (mga pangalan ng function) na imamapa
CWE-327, nang hindi nakikita ang default na antas ng panganib o detalyadong teksto ng babala, patakbuhin ang ``flawfinder
--listrules | grep CWE-327 | gupitin -f1''. Maaari mo ring makita ang mga token nang walang CWE mapping
sa ganitong paraan sa pamamagitan ng pagpapatakbo ng ``flawfinder -D --listrules | grep -v CWE-''. Gayunpaman, habang
--listrules ay naglilista ng lahat ng mga elemento ng seguridad ng CWE, naglilista lamang ito ng mga default na pagmamapa mula sa CWE
mga elemento ng seguridad sa mga CWE identifier. Hindi kasama dito ang mga refinement na flawfinder
naaangkop (hal., sa pamamagitan ng pagsusuri sa mga parameter ng function).

Kung gusto mo ng detalyado at eksaktong pagmamapa sa pagitan ng mga elemento ng seguridad ng CWE at CWE
mga identifier, ang flawfinder source code (kasama sa pamamahagi) ay ang pinakamagandang lugar
para sa impormasyong iyon. Ang detalyadong impormasyong ito ay pangunahing interesado sa iilan
mga taong sinusubukang pinuhin ang CWE mappings ng flawfinder o pinuhin ang CWE sa pangkalahatan.
Ang source code ay nagdodokumento ng pagmamapa sa pagitan ng mga elemento ng seguridad sa kani-kanilang CWE
mga identifier, at isang file ng Python. Tinutukoy ng dataset ng ``c_rules'' ang karamihan sa mga panuntunan,
na may reference sa isang function na maaaring gumawa ng karagdagang mga pagpipino. Maaari mong hanapin ang
dataset para sa mga pangalan ng function upang makita kung ano ang nabuong CWE bilang default; kung ang unang parameter ay
hindi ``normal'' kung gayon iyon ang pangalan ng isang paraan ng pagpino ng Python na maaaring pumili ng iba
Mga CWE (depende sa karagdagang impormasyon). Sa kabaligtaran, maaari kang maghanap para sa ``CWE-number''
at hanapin kung anong mga elemento ng seguridad (mga lagda o pattern) ang tumutukoy sa CWE identifier na iyon.
Para sa karamihan ng mga tao, ito ay higit pa sa kailangan nila; karamihan sa mga tao ay nais lamang na i-scan ang kanilang
source code upang mabilis na makahanap ng mga problema.

SEGURIDAD

Ang buong punto ng tool na ito ay tumulong sa paghahanap ng mga kahinaan upang maayos ang mga ito.
Gayunpaman, dapat alam ng mga developer at reviewer kung paano bumuo ng secure na software para magamit ito
kasangkapan, dahil kung hindi, a lokohin sa a kasangkapan is pa rin a lokohin. Ang libro ko sa
http://www.dwheeler.com/secure-programs maaaring makatulong.

Ang tool na ito ay dapat, sa karamihan, isang maliit na bahagi ng isang mas malaking proseso ng pagbuo ng software
idinisenyo upang alisin o bawasan ang epekto ng mga kahinaan. Mga developer at reviewer
kailangang malaman kung paano bumuo ng secure na software, at kailangan nilang ilapat ang kaalamang ito upang mabawasan
ang mga panganib ng mga kahinaan sa unang lugar.

Ang iba't ibang mga tool sa paghahanap ng kahinaan ay may posibilidad na makahanap ng iba't ibang mga kahinaan. Kaya, ikaw
ay pinakamahusay na gumamit ng pagsusuri ng tao at iba't ibang mga tool. Makakatulong ang tool na ito sa paghahanap ng ilan
mga kahinaan, ngunit hindi lahat.

Dapat lagi mong pag-aralan a kopyahin ng source program na sinusuri, hindi isang direktoryo
na maaaring baguhin ng isang developer habang ginagawa ng flawfinder ang pagsusuri. Ito ay
lalo na totoo kung hindi mo kailangang magtiwala sa isang developer ng program na sinusuri.
Kung may kontrol ang isang attacker sa mga file habang sinusuri mo ang mga ito, magagawa ng attacker
ilipat ang mga file sa paligid o baguhin ang kanilang mga nilalaman upang maiwasan ang pagkakalantad ng isang problema sa seguridad
(o lumikha ng impresyon ng isang problema kung saan wala). Kung nag-aalala ka
malisyosong programmer dapat mo pa rin itong gawin, dahil pagkatapos ng pagsusuri kakailanganin mong gawin ito
i-verify na ang code sa kalaunan ay tatakbo ay ang code na iyong nasuri. Gayundin, huwag gamitin ang
--allowlink na opsyon sa mga ganitong kaso; ang mga umaatake ay maaaring lumikha ng mga nakakahamak na simbolikong link sa mga file
sa labas ng kanilang lugar ng source code (tulad ng / etc / passwd).

Ang mga sistema ng pamamahala ng source code (tulad ng SourceForge at Savannah) ay tiyak na nahuhulog dito
kategorya; kung pinapanatili mo ang isa sa mga system na iyon, kopyahin o i-extract muna ang mga file sa
isang hiwalay na direktoryo (na hindi makokontrol ng mga umaatake) bago patakbuhin ang flawfinder o
anumang iba pang tool sa pagsusuri ng code.

Tandaan na ang flawfinder ay nagbubukas lamang ng mga regular na file, direktoryo, at (kung hiniling) na simboliko
mga link; hinding-hindi ito magbubukas ng iba pang uri ng mga file, kahit na may simbolikong link na ginawa sa kanila.
Kinokontra nito ang mga umaatake na naglalagay ng mga hindi pangkaraniwang uri ng file sa source code. Gayunpaman, ito
gagana lamang kung ang filesystem na sinusuri ay hindi mababago ng isang umaatake sa panahon ng
pagsusuri, gaya ng inirerekomenda sa itaas. Hindi rin gumagana ang proteksyong ito sa mga platform ng Cygwin,
sa kasamaang palad.

Ang mga Cygwin system (Unix emulation sa itaas ng Windows) ay may karagdagang problema kung flawfinder
ay ginagamit upang pag-aralan ang mga programang hindi mapagkakatiwalaan ng analyst. Ang problema ay dahil sa isang disenyo
kapintasan sa Windows (na minana nito mula sa MS-DOS). Sa Windows at MS-DOS, ilang mga filename
(hal., ``com1'') ay awtomatikong itinuturing ng operating system bilang mga pangalan ng
peripheral, at totoo ito kahit na ibinigay ang buong pathname. Oo, Windows at MS-DOS
talagang masama ang disenyo nito. Tinatalakay ito ng Flawfinder sa pamamagitan ng pagsuri kung ano ang isang filesystem
object ay, at pagkatapos ay pagbubukas lamang ng mga direktoryo at mga regular na file (at mga symlink kung pinagana).
Sa kasamaang palad, hindi ito gumagana sa Cygwin; sa hindi bababa sa ilang bersyon ng Cygwin sa ilan
mga bersyon ng Windows, sinusubukan lamang na matukoy kung ang isang file ay isang uri ng device ay maaaring maging sanhi ng
programang mag-hang. Ang isang solusyon ay upang tanggalin o palitan ang pangalan ng anumang mga filename na binibigyang-kahulugan
bilang mga pangalan ng device bago isagawa ang pagsusuri. Ang mga tinatawag na ``nakareserbang pangalan'' ay
CON, PRN, AUX, CLOCK$, NUL, COM1-COM9, at LPT1-LPT9, opsyonal na sinusundan ng extension
(hal., ``com1.txt''), sa anumang direktoryo, at sa anumang kaso (ang Windows ay case-insensitive).

Do hindi mag-load o magkaiba ang mga hitlist mula sa mga hindi pinagkakatiwalaang source. Ang mga ito ay ipinatupad gamit ang
Python pickle module, at ang pickle module ay hindi inilaan upang maging secure laban sa mali
o maliciously constructed data. Ang mga nakaimbak na hitlist ay inilaan para magamit sa ibang pagkakataon ng pareho
user na lumikha ng hitlist; sa kontekstong iyon ang paghihigpit na ito ay hindi isang problema.

Gumamit ng flawfinder online gamit ang mga serbisyo ng onworks.net