Flawfinder - מקוון בענן

תָכְנִית:

שֵׁם

Flawfinder - מצא באופן מילוני פגמי אבטחה פוטנציאליים ("היטים") בקוד המקור

תַקצִיר

מאתר פגמים [- עזרה|-h] [--גִרְסָה] [-- רשימות]
[--allowlink] [--followdotdir] [--אין קישור]
[--patch=שם הקובץ|-P שם הקובץ]
[--כניסות|-I] [ --minlevel=X | -m X ] [--חיובי כוזב|-F]
[--לעולם אל תתעלם|-n]
[--regex=תַבְנִית | -e תַבְנִית]
[--הֶקשֵׁר|-c] [--עמודות|-C] [--נתונים בלבד|-D] [--html|-H] [--מִיָדִי|-i]
[--שורה בודדת|-S] [--השמטת זמן] [--שֶׁקֶט|-Q]
[--loadhitlist=F] [--savehitlist=F] [--diffhitlist=F]
[--] [ מָקוֹר קוד פילה or מָקוֹר שורש בספרייה ]+

תיאור

Flawfinder מחפש דרך קוד המקור C/C++ ומחפש פגמי אבטחה פוטנציאליים. ל
הפעל את Flawfinder, פשוט תן ל-Flawfinder רשימה של ספריות או קבצים. לכל ספרייה
נתון, כל הקבצים שיש להם סיומות שמות קובץ C/C++ בספרייה זו (ושלה
תת-ספריות, באופן רקורסיבי) ייבדקו. לכן, עבור רוב הפרויקטים, פשוט לתת
Flawfinder שם הספרייה העליונה ביותר של קוד המקור (השתמש ב-``.'' עבור הנוכחי
ספרייה), ו-Flawfinder יבחן את כל קוד המקור C/C++ של הפרויקט. אם אתה
רק רוצה לקבל שינויים נבדק, שמור הבדל מאוחד של השינויים הללו (נוצר על ידי GNU
"diff -u" או "svn diff" או "git diff") בקובץ תיקון והשתמש באפשרות --patch (-P).

Flawfinder יפיק רשימה של ``להיטים'' (פגמי אבטחה פוטנציאליים), ממוינים לפי סיכון; ה
הלהיטים המסוכנים ביותר מוצגים תחילה. רמת הסיכון מוצגת בתוך סוגריים מרובעים ומשתנה
מ-0, סיכון קטן מאוד, ל-5, סיכון גדול. רמת סיכון זו תלויה לא רק ב
פונקציה, אלא על ערכי הפרמטרים של הפונקציה. למשל, קבוע
מחרוזות הן לרוב פחות מסוכנות ממחרוזות משתנות לחלוטין בהקשרים רבים, ובאלה
בהקשרים שלפגיעה תהיה רמת סיכון נמוכה יותר. Flawfinder יודע על gettext (נפוץ
הספרייה לתוכניות בינלאומיות) ותטפל במחרוזות קבועות שעברו
gettext כאילו היו מחרוזות קבועות; זה מפחית את מספר ההתאמות הכוזבות ב
תוכניות בינלאומיות. Flawfinder יעשה את אותו הדבר עם _T() ו
_TEXT(), פקודות מאקרו נפוצות של Microsoft לטיפול בתוכניות בינלאומיות. מוצא פגמים
מתעלם בצורה נכונה מרוב הטקסט בתוך הערות ומחרוזות. בדרך כלל, Flawfinder מציג הכל
פגעים עם רמת סיכון של לפחות 1, אבל אתה יכול להשתמש באפשרות --minlevel כדי להציג רק
להיטים עם רמות סיכון גבוהות יותר אם תרצה. תיאורי הלהיט מציינים גם את המשותף הרלוונטי
מזהה(ים) של ספירת חולשה (CWE) בסוגריים, כפי שנדון להלן. מוצא פגמים
רשמית תואם CWE.

לא כל פגיעה היא למעשה פרצת אבטחה, ולא כל פרצת אבטחה
נמצא בהכרח. עם זאת, מבחן הפגמים יכול להוות סיוע באיתור והסרה
פרצות אבטחה. דרך נפוצה להשתמש ב-flawfinder היא תחילה ליישם את ה-flawfinder
קבוצה של קוד מקור ובחן את הפריטים בסיכון הגבוה ביותר. לאחר מכן, השתמש ב--inputs כדי לבחון
את מיקומי הקלט, ובדוק כדי לוודא שרק ערכי קלט חוקיים ובטוחים קיימים
מתקבל ממשתמשים לא מהימנים.

לאחר שבדקת תוכנית, תוכל לסמן שורות קוד מקור שהן למעשה בסדר אבל
לגרום לאזהרות מזויפות כדי ש-Flawfinder יפסיק להתלונן עליהם. לסמן א
כדי שהאזהרות הללו ידחקו, שים הערה בפורמט מיוחד על אחד מהם
אותה שורה (אחרי קוד המקור) או לגמרי לבד בשורה הקודמת. התגובה
חייב להיות אחד משני הפורמטים הבאים:

· // מגלה פגמים: התעלם

· /* מאתר פגמים: התעלם */

למען התאימות, אתה יכול להחליף את "Flawfinder:" ב-"ITS4:" או "RATS:" באלה
הערות בפורמט מיוחד. מכיוון שיכול להיות ששורות כאלה שגויות, אתה יכול להשתמש
אפשרות --neverignore, שגורמת ל-Flawfinder לעולם לא להתעלם מכל שורה ולא משנה מה
הנחיות ההערות אומרות (באופן מבלבל יותר, --neverignore מתעלם מההתעלמות).

Flawfinder משתמש במסד נתונים פנימי הנקרא ``חוקים''; ערכת הכללים מזהה
פונקציות שהן סיבות נפוצות לליקוי אבטחה. סט הכללים הסטנדרטי כולל גדול
מספר בעיות פוטנציאליות שונות, כולל שתי בעיות כלליות שיכולות להשפיע על כל אחת מהן
תוכנית C/C++, כמו גם מספר פונקציות ספציפיות דמויות Unix ו-Windows
בעייתי במיוחד. האפשרות --listrules מדווחת על רשימת הכללים הנוכחיים ו
רמות סיכון ברירת המחדל שלהם. כפי שצוין לעיל, כל פגם אבטחה פוטנציאלי שנמצא בנתון
קובץ קוד המקור (התואם לערך בערכת הכללים) נקרא ``hit,'' וקבוצת
להיטים שנמצאו במהלך כל ריצה מסוימת של התוכנית נקראים ``hitlist''
ניתן לשמור (באמצעות --savehitlist), לטעון מחדש להצגה מחדש (באמצעות --loadhitlist), ו
אתה יכול להציג רק את ההיטים השונים מהרצה אחרת (באמצעות --diffhitlist).

Flawfinder הוא כלי פשוט, המוביל לכמה יתרונות וחסרונות בסיסיים. Flawfinder עובד
על ידי ביצוע אסימון מילוני פשוט (דילוג על הערות וסימון נכון של מחרוזות),
מחפש התאמות אסימונים למסד הנתונים (במיוחד כדי למצוא קריאות לפונקציה).
Flawfinder דומה אפוא ל-RATS ו-ITS4, שגם הם משתמשים בטוקניזציה מילונית פשוטה.
לאחר מכן, Flawfinder בוחן את הטקסט של פרמטרי הפונקציה כדי להעריך את הסיכון. בניגוד
כלים כגון סד, דגלי האזהרה של gcc, ו-clang, Flawfinder עושה זאת לֹא להשתמש או יש
גישה למידע על זרימת בקרה, זרימת נתונים או סוגי נתונים בעת חיפוש
נקודות תורפה פוטנציאליות או הערכת רמת הסיכון. לפיכך, פגם יעשה זאת
מייצרים בהכרח תוצאות שגויות רבות עבור פגיעויות ולא מצליחים לדווח על רבות
פגיעויות. מצד שני, Flawfinder יכול למצוא נקודות תורפה בתוכניות
לא ניתן לבנות או לא ניתן לקשר. לעתים קרובות זה יכול לעבוד עם תוכניות שאפילו לא יכולות להיות
מלוקט (לפחות על ידי הכלים של המבקר). Flawfinder גם לא מתבלבל כל כך
הגדרות מאקרו ועוד מוזרויות שכלים מתוחכמים יותר מתקשים איתם.
Flawfinder יכול להיות שימושי גם כהקדמה פשוטה לכלי ניתוח סטטי ב
כללי, מכיוון שקל להתחיל להשתמש בו וקל להבנה.

כל שם קובץ שניתן בשורת הפקודה ייבדק (גם אם אין לו שם רגיל
סיומת שם קובץ C/C++); כך אתה יכול לאלץ את Flawfinder לבחון קבצים ספציפיים שאתה
רצון עז. בזמן חיפוש ספריות רקורסיבי, Flawfinder רק נפתח ובוחן
קבצים רגילים שיש להם סיומות שמות קובץ C/C++. Flawfinder מניח שקבצים כן
קבצי C/C++ אם יש להם את הסיומות ".c", ".h", ".ec", ".ecp", ".pgc", ".C", ".cpp",
".CPP", ".cxx", ".cc", ".CC", ".pcc", ".hpp" או ".H". שם הקובץ ``-'' פירושו ה-
קלט סטנדרטי. כדי למנוע בעיות אבטחה, קבצים מיוחדים (כגון קבצים מיוחדים למכשיר
ו-Name pipes) תמיד מדלגים, וכברירת מחדל מדלגים על קישורים סמליים (ה
--אפשרות הקישור באה בעקבות קישורים סמליים).

אחרי רשימת ההיטים יש סיכום קצר של התוצאות (השתמש ב-D כדי להסיר את זה
מֵידָע). זה יציג את מספר הכניסות, השורות שנותחו (כפי שדווח על ידי wc -l), וכן
שורות המקור הפיזי של הקוד (SLOC) שנותחו. SLOC פיזי הוא לא ריק, לא
שורת הערות. לאחר מכן, הוא יציג את מספר ההיטים בכל רמה; שימו לב שיהיה
לעולם אל תהיה להיט ברמה נמוכה מ-minlevel (1 כברירת מחדל). לפיכך, "[0] 0 [1] 9"
פירושו שברמה 0 דווחו 0 פגיעות, וברמה 1 היו 9 פגיעות
דיווח. בשלב הבא הוא יציג את מספר ההיטים ברמה נתונה או יותר (לכן רמה 3+
יש את הסכום של מספר הפגיעות ברמה 3, 4 ו-5). לפיכך, ערך של "[0+] 37"
מראה שברמה 0 ומעלה היו 37 כניסות (ערך 0+ תמיד יהיה זהה
כמספר ה"להיטים" למעלה). להיטים לכל KSLOC יוצגו הבא; זה כל אחד מה"רמה או
ערכים גבוהים יותר מוכפלים ב-1000 ומחולקים ב-SLOC הפיזי. אם קישורי סימול היו
דילוג, הספירה של אלה מדווחת. אם להיטים הודחקו (באמצעות "התעלם"
הנחיה בהערות קוד מקור כמתואר לעיל), המספר המודחק מדווח.
רמת הסיכון המינימלית שתיכלל בדוח מוצגת; כברירת מחדל זה 1
(השתמש ב--minlevel כדי לשנות זאת). הסיכום מסתיים בתזכורות חשובות: לא כל פגיעה
הוא בהכרח פגיעות אבטחה, וייתכנו פרצות אבטחה אחרות
לא דווח על ידי הכלי.

Flawfinder משוחרר תחת רישיון GNU GPL גרסה 2 ואילך (GPLv2+).

Flawfinder עובד בדומה לתוכנית אחרת, ITS4, שאינה קוד פתוח לחלוטין
תוכנה (כפי שמוגדרת בהגדרת הקוד הפתוח) ולא תוכנה חופשית (כפי שהוגדרה על ידי
קרן תוכנה חופשית). המחבר של Flawfinder מעולם לא ראה את קוד המקור של ITS4.

קָצָר הדרכה

להלן דוגמה קצרה כיצד ניתן להשתמש ב-Flawfinder. תאר לעצמך שיש לך את ה-C/C++
קוד מקור עבור תוכנה כלשהי בשם xyzzy (שאולי כתבת או לא), ו
אתה מחפש פרצות אבטחה (כדי שתוכל לתקן אותן לפני לקוחות
נתקלים בנקודות התורפה). עבור הדרכה זו, אני מניח שאתה משתמש ב-Unix-
כמו מערכת, כגון Linux, OpenBSD או MacOS X.

אם קוד המקור נמצא בתיקייה משנה בשם xyzzy, כנראה שתתחיל בפתיחת a
חלון טקסט ושימוש בהגדרות ברירת המחדל של Flawfinder, כדי לנתח את התוכנית ולדווח א
רשימה מועדפת של פרצות אבטחה פוטנציאליות (ה''פחות'' רק מוודאת את
התוצאות נשארות על המסך):
פגם xyzzy | פָּחוּת

בשלב זה, תראה מספר רב של ערכים. לכל ערך יש שם קובץ, א
נקודתיים, מספר שורה, רמת סיכון בסוגריים (כאשר 5 הוא המסוכן ביותר), קטגוריה,
שם הפונקציה, ותיאור מדוע מגלה הפגמים חושב שהקו הוא א
פגיעות. Flawfinder ממיין בדרך כלל לפי רמת סיכון, ומציג תחילה את הפריטים המסוכנים ביותר;
אם יש לך זמן מוגבל, כנראה שעדיף להתחיל לעבוד על הפריטים הכי מסוכנים ו
להמשיך עד שיגמר לך הזמן. אם אתה רוצה להגביל את התצוגה לסיכונים עם א
רמת סיכון מסוימת ומעלה, השתמש באפשרות --minlevel. אם אתה מקבל א
מספר יוצא דופן של תוצאות חיוביות שגויות מכיוון ששמות משתנים נראים מסוכנים
שמות פונקציות, השתמש באפשרות -F כדי להסיר דיווחים עליהם. אם אתה לא מבין
את הודעת השגיאה, אנא עיין במסמכים כגון כתיבה לאבטח תוכניות ל לינוקס ו
יוניקס איך ⟨http://www.dwheeler.com/secure-programs⟩ בשעה http://www.dwheeler.com/secure-
תוכניות המספקות מידע נוסף על כתיבת תוכניות מאובטחות.

לאחר שתזהה את הבעיה והבנת אותה, תוכל לתקן אותה. מדי פעם אתה יכול
רוצה לעשות מחדש את הניתוח, גם בגלל שמספרי השורות ישתנו ו לוודא
שהקוד החדש עדיין לא מציג פגיעות אחרת.

אם קבעתם שקו כלשהו אינו באמת בעיה, ואתם בטוחים בכך, אתם יכולים
הכנס בדיוק לפני או בשורה הפוגעת תגובה כמו
/* מגלה פגמים: התעלם */
כדי למנוע מהם להופיע בפלט.

לאחר שעשית את זה, אתה צריך לחזור ולחפש את הקלט של התוכנית, כדי לבצע
ודא שהתוכנה מסננת היטב את כל התשומות הבלתי מהימנות שלה. Flawfinder יכול
זהה כניסות תוכניות רבות על ידי שימוש באפשרות --inputs, כמו זה:
Flawfinder --מכניס xyzzy

Flawfinder יכול להשתלב היטב עם עורכי טקסט וסביבות פיתוח משולבות;
עיין בדוגמאות למידע נוסף.

Flawfinder כולל אפשרויות רבות אחרות, כולל אפשרויות ליצירת גרסאות HTML של
פלט (שימושי עבור צגים יפים יותר). הסעיף הבא מתאר את האפשרויות הללו בהרחבה
פרט.

אפשרויות

ל-Flawfinder יש מספר אפשרויות, אותן ניתן לקבץ לאפשרויות השולטות בעצמה
תיעוד, בחר נתוני קלט, בחר אילו להיטים להציג, בחר את פורמט הפלט,
ולבצע ניהול רשימת היטלים. Flawfinder תומך בתחביר הסטנדרטי המוגדר ב-
POSIX (גיליון 7, מהדורת 2013) סעיף ``מוסכמות שירות`'. זה גם תומך ב-GNU
אפשרויות ארוכות (אפשרויות טופס עם מקף כפול --אוֹפְּצִיָהכהגדרתו ב- גנה C סִפְרִיָה
התייחסות מדריך ל ``מוסכמות תחביר ארגומנט תוכנית'' ו גנה סִמוּל תקנים
``סטנדרטים עבור ממשקי שורת פקודה''. ניתן לספק ארגומנטים ארוכי אופציה כ
``--name=value'' או ``-name value''. ניתן לגשת לחלק מהאפשרויות רק באמצעות יותר
מוסכמות אפשרויות ארוכות של GNU קריאות; אפשרויות נפוצות נתמכות גם על ידי הישנים יותר
אמנה של אופציות של אות אחת.

תיעוד
- עזרה

-h הצג מידע על שימוש (עזרה).

--גִרְסָה מציג (רק) את מספר הגרסה ויוצא.

-- רשימות רשום את התנאים (אסימונים) המעוררים בדיקה נוספת, סיכון ברירת המחדל שלהם
רמה, ואזהרת ברירת המחדל (כולל מזהי CWE), אם
רלוונטי), כולם מופרדים בכרטיסיות. המונחים הם בעיקר שמות של פוטנציאל-
פונקציות מסוכנות. שים לב שרמת הסיכון המדווחת ואזהרה עבור חלק
הקוד הספציפי עשוי להיות שונה מברירת המחדל, תלוי איך המונח הוא
בשימוש. שלב עם -D אם אתה לא רוצה את הכותרת הרגילה. מוצא פגמים
גרסה 1.29 שינתה את המפריד מרווחים לטאבים, והוסיפה את ברירת המחדל
שדה אזהרה.

בחירה קֶלֶט נתונים
--allowlink לאפשר שימוש בקישורים סמליים; בדרך כלל מדלגים על קישורים סמליים. אל תעשה
השתמש באפשרות זו אם אתה מנתח קוד על ידי אחרים; התוקפים יכולים לעשות הרבה
דברים שיגרמו לבעיות עבור ניתוח כאשר אפשרות זו מופעלת. ל
לדוגמה, תוקף יכול להכניס קישורים סמליים לקבצים כגון / etc / passwd
(הדלפת מידע על הקובץ) או ליצור לולאה מעגלית, מה שכן
לגרום ל-Flawfinder לפעול ``לנצח''. בעיה נוספת עם הפעלת זה
האפשרות היא שאם אותו קובץ מופנה מספר פעמים באמצעות סימבולית
קישורים, הוא ינותח מספר פעמים (וכך ידווח מספר פעמים).
שימו לב ש-Flawfinder כבר כולל הגנה מסוימת מפני קישורים סמליים
לסוגי קבצים מיוחדים כגון סוגי קבצים במכשיר (למשל, /dev/zero או
C:\mystuff\com1). שים לב שעבור Flawfinder גרסה 1.01 ומעלה, זה היה
ברירת המחדל.

--followdotdir
הזן ספריות ששמותיהן מתחילים ב-".". בדרך כלל מדריכים כאלה
התעלמו, מכיוון שהם בדרך כלל כוללים נתונים פרטיים של בקרת גרסאות (כגון
.git/ או .svn/), תצורות וכן הלאה.

--אין קישור התעלמו. מבחינה היסטורית זה השבית את הקישורים הסמליים הבאים; ההתנהגות הזאת
הוא כעת ברירת המחדל.

--patch=קובץ תיקון

-P קובץ תיקון
בדוק את הקבצים או הספריות שנבחרו, אך דווח רק על כניסות בשורות
מתווספים או משתנים על ידי קובץ התיקון הנתון. קובץ התיקון חייב להיות ב-a
פורמט הבדל מאוחד מזוהה (למשל, הפלט של GNU "diff -u old new",
"svn diff", או "git diff [commit]"). Flawfinder מניח שיש לתיקון
כבר הוחל על הקבצים. קובץ התיקון יכול לכלול גם שינויים ב
קבצים לא רלוונטיים (פשוט יתעלמו מהם). מספרי השורות המופיעים ב-
קובץ תיקון משמשים כדי לקבוע אילו שורות שונו, אז אם יש לך
שינה את הקבצים מאז שקובץ התיקון נוצר, צור מחדש את קובץ התיקון
ראשון. היזהר ששמות הקבצים של הקבצים החדשים ניתנים בקובץ התיקון
חייב להתאים בדיוק, כולל אותיות גדולות/קטנות, קידומת נתיב וספרייה
מפריד (\ לעומת /). רק פורמט הבדל מאוחד מתקבל (GNU diff, svn
diff, ופלט git diff בסדר); אם יש לך פורמט אחר, שוב
לשקם אותו תחילה. רק כניסות המתרחשות בשורות שהשתנו כתוצאה מכך, או
מיד מעליהם ומתחתיהם, מדווחים. אפשרות זו מרמזת
--לעולם אל תתעלם.

בחירה להיטים ל לְהַצִיג
--כניסות

-I הצג רק פונקציות שמקבלות נתונים מחוץ לתוכנית; זה גם קובע
רמה נמוכה ל-0.

--minlevel=X

-m X הגדר את רמת הסיכון המינימלית ל-X להכללה ברשימת ההיטים. זה יכול להיות מ-0 (``לא
סיכון'') עד 5 (``סיכון מקסימלי''); ברירת המחדל היא 1.

--חיובי כוזב

-F אל תכלול התאמות שסביר להניח שיהיו תוצאות חיוביות שגויות. נכון לעכשיו, זה אומר
שמתעלמים משמות פונקציות אם לא עוקבים אחריהם "(", וזה
הצהרות של מערכי תווים אינן מצוינות. לכן, אם יש לך השתמש במשתנה
בשם "גישה" בכל מקום, זה יבטל הפניות לרגיל הזה
מִשְׁתַנֶה. זו לא ברירת המחדל, כי זה גם מגדיל את הסבירות של
חסרים להיטים חשובים; במיוחד, שמות פונקציות ב-#define סעיפים וקריאות
דרך מצביעי פונקציה יתפספסו.

--לעולם אל תתעלם

-n לעולם אל תתעלם מבעיות אבטחה, גם אם יש להן הנחיית ''התעלם'' ב-a
איך? 'או' מה.

--regexp=תַבְנִית

-e תַבְנִית
דווח רק על התאמות עם טקסט התואם לתבנית הביטוי הרגיל PATTERN.
לדוגמה, כדי לדווח רק על התאמות המכילות את הטקסט "CWE-120", השתמש ב-`--regex
CWE-120 אינץ'. שמות דגל אפשרויות אלה זהים ל-grep.

בחירה תְפוּקָה פוּרמָט
--עמודות

-C הצג את מספר העמודה (כמו גם את שם הקובץ ומספר השורה) של כל פגיעה;
זה מוצג אחרי מספר השורה על ידי הוספת נקודתיים ומספר העמודה פנימה
השורה (התו הראשון בשורה הוא עמודה מספר 1). זה שימושי
עבור עורכים שיכולים לקפוץ לעמודות ספציפיות, או לשילוב עם אחרים
כלים (כגון אלה לסינון נוסף של תוצאות שגויות).

--הֶקשֵׁר

-c הצג את ההקשר, כלומר, השורה עם הפגם הפוטנציאלי "מכה". כברירת מחדל ה
הקו מוצג מיד לאחר האזהרה.

--נתונים בלבד

-D אל תציג את הכותרת העליונה והתחתונה. השתמש בזה יחד עם --שקט כדי לראות רק
הנתונים עצמם.

--html

-H עצב את הפלט כ-HTML במקום כטקסט פשוט.

--מִיָדִי

-i הציגו מיד להיטים (אל תחכו רק עד הסוף).

--שורה בודדת

-S הצג כשורה בודדת של פלט טקסט עבור כל היט. שימושי לאינטראקציה
עם כלי קומפילציה.

--השמטת זמן השמט מידע על תזמון. זה שימושי עבור מבחני רגרסיה של Flawfinder
עצמו, כך שהפלט לא משתנה בהתאם לזמן הניתוח
לוקח.

--שֶׁקֶט

-Q אל תציג מידע סטטוס (כלומר אילו קבצים נבדקים) בזמן
הניתוח ממשיך.

רשימת חיסול ניהול שוטף
--savehitlist=F
שמור את כל ההיטים שהתקבלו ("רשימת ההיטים") ב-F.

--loadhitlist=F
טען את רשימת ההיט מ-F במקום לנתח תוכניות מקור. אזהרה: תעשה לֹא
טען רשימות התאמה ממקורות לא מהימנים (מסיבות אבטחה).

--diffhitlist=F
הצג רק התאמות (נטענות או מנותחות) שלא ב-F. ככל הנראה נוצרו
בעבר השתמש ב--savehitlist. אזהרה: תעשה לֹא הבדל רשימות היט מ לא מהימן
מקורות (מסיבות אבטחה). אם האפשרות --loadhitlist לא מסופקת,
זה יציג את ההתאמות בקובצי קוד המקור המנותחים שלא היו
מאוחסן בעבר ב-F. אם נעשה בו שימוש יחד עם --loadhitlist, זה יציג את
כניסות ברשימת ההיט הנטענת לא ב-F. אלגוריתם ההבדל הוא
שמרני; התאמות נחשבות ל"זהות" רק אם יש להן אותו דבר
שם הקובץ, מספר השורה, מיקום העמודה, שם הפונקציה ורמת הסיכון.

דוגמאות

להלן דוגמאות שונות כיצד להפעיל את Flawfinder. הדוגמאות הראשונות מראות שונות
אפשרויות שורת פקודה פשוטות. Flawfinder נועד לעבוד היטב עם עורכי טקסט ו
סביבות פיתוח משולבות, אז הסעיפים הבאים מראים כיצד לשלב את Flawfinder
לתוך vim ו-emacs.

פָּשׁוּט שורת הפקודה אפשרויות
מאתר פגמים /usr/src/linux-3.16
בדוק את כל קבצי C/C++ בספרייה /usr/src/linux-3.16 ואת כל הקבצים שלה
ספריות משנה (רקורסיביות), המדווחות על כל ההתאמות שנמצאו. כברירת מחדל
Flawfinder ידלג על קישורים וספריות סמליות עם שמות שמתחילים ב
תקופה.

מאתר פגמים --minlevel=4 .
בדוק את כל קבצי C/C++ בספרייה הנוכחית ובתתי הספריות שלה
(רקורסיבית); דווח רק על פגיעויות ברמה 4 ומעלה (השתיים הגבוהות ביותר
רמות הסיכון).

מאתר פגמים --כניסות mydir
בדוק את כל קבצי C/C++ ב-mydir ובתיקיות המשנה שלו (באופן רקורסיבי), ו
פונקציות דיווח שלוקחות תשומות (כדי שתוכל להבטיח שהן מסננות את
תשומות כראוי).

מאתר פגמים --לעולם אל תתעלם mydir
בדוק את כל קבצי C/C++ בספריית mydir ובתיקיות המשנה שלה,
כולל אפילו את ההיטים המסומנים להתעלמות בהערות הקוד.

מאתר פגמים -QD mydir
בדוק את mydir ודווח רק על התוצאות בפועל (הסרת הכותרת ו
כותרת תחתונה של הפלט). טופס זה שימושי אם הפלט יוכנס לצינור
כלים נוספים לניתוח נוסף. ה-C (--עמודות) ו-S (--יחידה)
אפשרויות יכולות להיות שימושיות גם אם אתה מעביר את הנתונים לכלים אחרים.

מאתר פגמים -QDSC mydir
בדוק את mydir, דיווח רק על התוצאות בפועל (ללא כותרת עליונה או תחתונה). כל אחד
פגיעה מדווחת בשורה אחת, ומספרי עמודות מדווחים. זה יכול להיות א
פקודה שימושית אם אתה מזין פלט מאתר הפגמים לכלים אחרים.

מאתר פגמים --שֶׁקֶט --html --הֶקשֵׁר mydir > results.html
בדוק את כל קבצי C/C++ בספריית mydir ובתיקיות המשנה שלה, ו
לייצר גרסה בפורמט HTML של התוצאות. ניהול קוד מקור
מערכות (כגון SourceForge ו- Savannah) עשויות להשתמש בפקודה כזו.

מאתר פגמים --שֶׁקֶט ---savehitlist שמורות.להיטים *.[ch]
בדוק את כל קבצי ה-.c ו-.h בספרייה הנוכחית. אל תדווח על
סטטוס העיבוד, ושמור את רשימת ההיטים שהתקבלה (קבוצת כל ההתאמות).
הקובץ saved.hits.

מאתר פגמים --diffhitlist שמורות.להיטים *.[ch]
בדוק את כל קבצי ה-.c ו-.h בספרייה הנוכחית, והראה את כל ההתאמות
לא היו כבר בקובץ saved.hits. זה יכול לשמש כדי להציג רק את
פרצות ``חדשות'' בתוכנית ששונתה, אם saved.hits נוצר מ
הגרסה הישנה יותר של התוכנית המנותחת.

מאתר פגמים --תיקון לאחרונה.תיקון .
בדוק את הספרייה הנוכחית באופן רקורסיבי, אך דווח רק על שורות שהיו
שונה או נוסף בקובץ התיקון שכבר הוחל בשם לאחרונה.תיקון.

מאתר פגמים --רגקס "CWE-120|CWE-126" src /
בדוק את הספרייה src רקורסיבית, אבל דווח רק על כניסות שבהן CWE-120 או
CWE-126 חל.

מזמין החל מ- מֶרֶץ
עורך הטקסט vim כולל מנגנון "תיקון מהיר" שעובד היטב עם Flawfinder, אז
שתוכלו לצפות בקלות בהודעות האזהרה ולקפוץ לקוד המקור הרלוונטי.

ראשית, עליך להפעיל את Flawfinder כדי ליצור רשימה של כניסות, ויש שתי דרכים לעשות זאת
תעשה את זה. הדרך הראשונה היא להפעיל תחילה את Flawfinder, ולאחר מכן (באמצעות הפלט שלו) להפעיל
מֶרֶץ. הדרך השנייה היא להפעיל (או להמשיך להפעיל) vim, ולאחר מכן להפעיל את Flawfinder
(בדרך כלל מבפנים vim).

לדרך הראשונה, הפעל את Flawfinder ואחסן את הפלט שלו באיזה FLAWFILE (נניח "flawfile"),
לאחר מכן הפעל את vim באמצעות אפשרות ה-q שלו, כך: "vim -q flawfile". הדרך השנייה
(להפעיל את מבחן הפגמים לאחר הפעלת vim) ניתן לעשות במגוון דרכים. האחת היא להפעיל
Flawfinder באמצעות פקודת מעטפת, ":!flawfinder-command > FLAWFILE", ולאחר מכן בצע את זה עם
הפקודה ":cf FLAWFILE". דרך נוספת היא לאחסן את פקודת מאתר הפגמים שלך
makefile (כמו, למשל, פסאודו-פקודה כמו "פגם"), ולאחר מכן הפעל את ":make flaw".

בכל המקרים האלה אתה צריך פקודה כדי ש-flawfinder תפעל. פקודה סבירה, אשר
ממקם כל פגע בשורה משלה (-S) ומסיר כותרות עליונות ותחתונות שיבלבלו
זה:

מאתר פגמים -SQD .

כעת תוכל להשתמש בפקודות עריכה שונות כדי להציג את התוצאות. הפקודה ":cn" מוצגת
הלהיט הבא; ":cN" מציג את הפגיעה הקודמת, ו-":cr" חוזר אחורה ללהיט הראשון.
":copen" יפתח חלון שיציג את רשימת ההיטים הנוכחית, הנקרא "התיקון המהיר
window"; ":cclose" יסגור את חלון התיקון המהיר. אם למאגר בחלון בשימוש יש
השתנה, והשגיאה נמצאת בקובץ אחר, הקפיצה לשגיאה תיכשל. אתה חייב
ודא שהחלון מכיל מאגר שניתן לנטוש לפני שתנסה לקפוץ ל-a
קובץ חדש, נניח על ידי שמירת הקובץ; זה מונע אובדן נתונים בשוגג.

מזמין החל מ- Emacs
עורך הטקסט / מערכת ההפעלה emacs כולל "מצב grep" ו"מצב קומפילציה"
מנגנונים שפועלים היטב עם מבחן הפגמים, מה שמקל על צפייה בהודעות אזהרה, קפיצה
לקוד המקור הרלוונטי, ותקן כל בעיה שתמצא.

ראשית, עליך להפעיל את Flawfinder כדי ליצור רשימה של הודעות אזהרה. אתה יכול להשתמש
"מצב grep" או "מצב קומפילציה" כדי ליצור רשימה זו. לעתים קרובות "מצב grep" נוח יותר;
זה משאיר את מצב ההידור ללא נגיעה כך שתוכל לבצע קומפילציה מחדש בקלות לאחר ששינית
משהו. עם זאת, אם אתה רוצה לקפוץ למיקום העמודה המדויק של פגיעה, הידור
מצב עשוי להיות נוח יותר מכיוון ש-emacs יכול להשתמש בפלט העמודה של Flawfinder כדי
קפוץ ישירות למיקום הנכון ללא כל תצורה מיוחדת.

כדי להשתמש במצב grep, הזן את הפקודה "Mx grep" ולאחר מכן הזן את מבחן הפגמים הדרוש
פקודה. כדי להשתמש במצב קומפילציה, הזן את הפקודה "Mx compile" והזן את הדרוש
פקודת מאתר הפגמים. זוהי פקודת מטא-מפתח, אז תצטרך להשתמש במקש המטא עבור
המקלדת שלך (זה בדרך כלל מקש ESC). כמו בכל פקודות emacs, תצטרך
לחץ על RETURN לאחר הקלדת "grep" או "קומפילציה". אז במערכות רבות, מצב ה-grep הוא
מופעל על ידי הקלדת ESC xgrep RETURN.

לאחר מכן עליך להזין פקודה, להסיר את כל מה שהיה שם קודם במידת הצורך. א
פקודה סבירה היא:

מאתר פגמים -SQDC .

פקודה זו הופכת כל דיווח היט לשורה בודדת, וזה הרבה יותר קל לכלים לעשות
ידית. האפשרויות השקט והנתונים בלבד מסירות את פרטי הסטטוס האחרים שאין בהם צורך
להשתמש בתוך emacs. התקופה הנגררת פירושה שהמדריך הנוכחי והכל
צאצאים מחפשים קוד C/C++, ומנתחים להם פגמים.

לאחר שהפעלת את Flawfinder, תוכל להשתמש ב-emacs כדי לקפוץ בתוצאות שלו. ה
הפקודה Cx ` (Control-x backtick) מבקרת במיקום קוד המקור עבור האזהרה הבאה
הוֹדָעָה. Cu Cx ` (control-u control-x backtick) מתחיל מחדש מההתחלה. אתה יכול
בקר במקור עבור הודעת שגיאה מסוימת על ידי מעבר להודעת ההיט ב-
*קומפילציה* מאגר או *grep* מאגר והקלדת מקש החזרה. (הערה טכנית: ב
מאגר קומפילציה, זה מעורר שגיאת compile-goto.) אתה יכול גם ללחוץ על העכבר-2
כפתור בהודעת השגיאה (אינך צריך לעבור קודם למאגר *קומפילציה*).

אם אתה רוצה להשתמש במצב grep כדי לדלג לעמודות ספציפיות של פגיעה, תצטרך לעשות זאת
הגדר במיוחד את emacs לעשות זאת. כדי לעשות זאת, שנה את משתנה emacs "grep-regexp-
alist". משתנה זה אומר ל-Emacs כיצד לנתח פלט של פקודת "grep", בדומה ל-
משתנה "compilation-error-regexp-alist" המפרט פורמטים שונים של שגיאות קומפילציה
הודעות.

מזמין החל מ- משולב צעצועי התפתחות סביבות (IDEs)
עבור (אחרים) IDEs, עיין בערכת התוספים של ה-IDE שלך.

משותף חוּלשָׁה ספירה (CWE)

ה-Common Weakness Enumeration (CWE) הוא "רשימה רשמית או מילון של תוכנות נפוצות
חולשות שיכולות להתרחש בארכיטקטורת התוכנה, העיצוב, הקוד או היישום של התוכנה
יכול להוביל לפרצות אבטחה שניתנות לניצול... שנוצרו כדי לשמש כשפה משותפת
לתיאור חולשות אבטחת תוכנה'' (http://cwe.mitre.org/about/faq.html). ל
מידע נוסף על CWEs, ראה http://cwe.mitre.org.

Flawfinder תומך ב-CWE והוא תואם באופן רשמי ל-CWE. תיאורי היט בדרך כלל
כלול מזהה רלוונטי של ספירת חולשה נפוצה (CWE) בסוגריים היכן שיש
ידוע כ-CWE רלוונטי. לדוגמה, רבות מההתאמות הקשורות למאגר מוזכרות
CWE-120, מזהה CWE עבור ``עותק מאגר ללא בדיקת גודל הקלט'' (aka
``Classic Buffer Overflow''). במקרים בודדים עשוי להיות רשום יותר ממזהה CWE אחד.
דוח ה-HTML כולל גם קישורי היפרטקסט להגדרות ה-CWE המתארחות ב-MITRE. ב
בדרך זו, Flawfinder מתוכנן לעמוד בדרישת CWE-Output.

רבים מה-CWEs שדווחו על ידי Flawfinder מזוהים ברשימת 25 המובילים של CWE/SANS לשנת 2011
(http://cwe.mitre.org/top25/). אנשים רבים ירצו לחפש CWEs ברשימה זו,
כגון CWE-120 (הצפת חיץ קלאסית), When Flawfinder ממפה ל-CWE שהוא יותר
כללי מאשר פריט 25 המובילים, הוא מפרט אותו בתור יותר כללי: ספציפי יותר (למשל,
CWE-119:CWE-120), כאשר יותר כללי הוא המיפוי בפועל. אם הכשלים ממפה לעוד
פריט CWE ספציפי שהוא מקרה ספציפי של פריט 25 המובילים, הוא רשום בטופס
top-25/more-specific (למשל, CWE-362/CWE-367), כאשר המיפוי האמיתי הוא הספציפי יותר
כניסה ל-CWE. אם אותה ערך ממפה למספר CWEs, ה-CWEs מופרדים בפסיקים
(זה קורה לעתים קרובות עם CWE-20, אימות קלט לא נכון). זה מפשט את החיפוש
CWEs מסוימים.

גרסה 2.7 של CWE (שוחררה ב-23 ביוני 2014) שימשה למיפוי. ה-CWE הנוכחי
מיפויים בוחרים את ה-CWE הספציפי ביותר שהכלי יכול לקבוע. בתיאוריה, רוב ה-CWE
אלמנטי אבטחה (חתימות/דפוסים שהכלי מחפש) יכולים להיות תיאורטית
ממופה ל-CWE-676 (שימוש בפונקציה פוטנציאלית מסוכנת), אך מיפוי כזה לא יהיה
מוֹעִיל. לפיכך, הועדפו מיפויים ספציפיים יותר היכן שניתן למצוא אותם. מוצא פגמים
הוא כלי לניתוח מילוני; כתוצאה מכך, זה לא מעשי שזה יהיה יותר ספציפי מאשר
המיפויים המיושמים כעת. זה גם אומר שזה לא סביר שצריך הרבה
עדכון עבור מטבע המפה; פשוט אין לו מספיק מידע כדי לצמצם ל-a
רמת CWE מפורטת ששינויי CWE בדרך כלל ישפיעו עליה. רשימת מזהי CWE
נוצרה אוטומטית באמצעות "make show-cwes", אז יש ביטחון שהרשימה הזו
זה נכון. אנא דווח על בעיות מיפוי CWE בתור באגים אם אתה מוצא כאלה.

Flawfinder עלול לא למצוא פגיעות, גם אם Flawfinder מכסה אחד מה-CWE הללו
חולשות. עם זאת, Flawfinder אכן מוצא נקודות תורפה המפורטות על ידי ה-CWEs שהוא מכסה,
והוא לא ידווח על קווים ללא נקודות תורפה אלו במקרים רבים. לפיכך, כמו
נדרש עבור כל כלי שמתכוון להיות תואם CWE, ל-Flawfinder יש שיעור של false
חיובים פחות מ-100% ושיעור שליליות כוזבות פחות מ-100%. Flawfinder כמעט
תמיד מדווח בכל פעם שהוא מוצא התאמה לרכיב אבטחה CWE (חתימה/דפוס as
מוגדר במסד הנתונים שלו), אם כי מבנים לא ברורים יכולים לגרום לו להיכשל (ראה BUGS
להלן).

Flawfinder יכול לדווח על ה-CWEs הבאים (אלה הם ה-CWEs ש-Flawfinder מכסה;
``*'' מסמן את אלו ברשימת 25 המובילים של CWE/SANS):

· CWE-20: אימות קלט לא תקין

· CWE-22: הגבלה לא נכונה של שם נתיב לספרייה מוגבלת (``מעבר נתיב'')

· CWE-78: נטרול לא תקין של אלמנטים מיוחדים בשימוש בפקודת מערכת הפעלה (``פקודה OS
זריקה'')*

· CWE-119: הגבלה לא נכונה של פעולות בתוך גבולות מאגר זיכרון (א
האב של CWE-120*, אז זה מוצג בתור CWE-119:CWE-120)

· CWE-120: העתקת מאגר ללא בדיקת גודל הקלט (``Classic Buffer Overflow'')*

· CWE-126: קריאה יתרה של מאגר

· CWE-134: מחרוזת פורמט בלתי מבוקרת*

· CWE-190: הצפת מספרים שלמים או עוקפת*

· CWE-250: ביצוע עם הרשאות מיותרות

· CWE-327: שימוש באלגוריתם קריפטוגרפי שבור או מסוכן*

· CWE-362: ביצוע במקביל באמצעות משאב משותף עם סנכרון לא תקין
(``מצב מירוץ'')

· CWE-377: קובץ זמני לא מאובטח

· CWE-676: שימוש בפונקציה שעלולה להיות מסוכנת*

· CWE-732: הקצאת הרשאה שגויה עבור משאב קריטי*

· CWE-785: שימוש בפונקציית מניפולציה של נתיב ללא מאגר בגודל מקסימלי (ילד של
CWE-120*, אז זה מוצג בתור CWE-120/CWE-785)

· CWE-807: הסתמכות על תשומות לא מהימנות בהחלטת אבטחה*

· CWE-829: הכללת פונקציונליות מתחום בקרה לא מהימן*

אתה יכול לבחור תת-קבוצה ספציפית של CWEs לדווח על ידי שימוש באפשרות ``--regex'' (-e).
אפשרות זו מקבלת ביטוי רגולרי, כך שאתה יכול לבחור מספר CWEs, למשל, ``--regex
"CWE-120|CWE-126"''. אם תבחר במספר CWEs עם ``|'' בשורת פקודה תעשה זאת
בדרך כלל צריך לצטט את הפרמטרים (מכיוון ש``|'' לא מצוטט הוא סמל הצינור).
Flawfinder נועד לעמוד בדרישת CWE-Searchable.

אם המטרה שלך היא לדווח על תת-קבוצה של CWEs הרשומים בקובץ, ניתן להשיג זאת
במערכת דמוית יוניקס באמצעות האפשרות ``--regex'' הידועה בשם ``-e''. הקובץ חייב להיות ב
פורמט ביטוי רגולרי. לדוגמה, ``flawfinder -e $(cat file1)'' ידווח רק
התאמות שתואמות לתבנית ב-``file1''. אם file1 הכיל ``CWE-120|CWE-126'' זה
ידווח רק על כניסות התואמות לאותם CWEs.

רשימה של כל רכיבי האבטחה של CWE (החתימות/תבניות שמחפש הפגמים)
ניתן למצוא על ידי שימוש באפשרות ``--listrules''. כל שורה מפרטת את אסימון החתימה
(בדרך כלל שם פונקציה) שעלול להוביל להיט, רמת הסיכון המוגדרת כברירת מחדל, וה-
אזהרת ברירת מחדל (הכוללת את מזהה ברירת המחדל של CWE). לרוב המטרות זהו
מספיק גם אם אתה רוצה לראות אילו רכיבי אבטחה CWE ממפים לאילו CWEs, או ה-
לַהֲפוֹך. לדוגמה, כדי לראות את מירב החתימות (שמות הפונקציות) שממפות אליהן
CWE-327, מבלי לראות את רמת הסיכון המוגדרת כברירת מחדל או טקסט אזהרה מפורט, הפעל את ``Flawfinder
--listrules | grep CWE-327 | לחתוך -f1''. אתה יכול גם לראות את האסימונים ללא מיפוי CWE
בדרך זו על ידי הפעלת ``flawfinder -D --listrules | grep -v CWE-''. עם זאת, תוך כדי
--listrules מפרט את כל רכיבי האבטחה של CWE, הוא מפרט רק את מיפויי ברירת המחדל מ-CWE
רכיבי אבטחה למזהי CWE. זה לא כולל את השכלולים שמוצאים פגמים
חל (למשל, על ידי בחינת פרמטרי פונקציה).

אם אתה רוצה מיפוי מפורט ומדויק בין רכיבי האבטחה של CWE ל-CWE
מזהים, קוד המקור של מאתר הפגמים (כלול בהפצה) הוא המקום הטוב ביותר
למידע זה. מידע מפורט זה מעניין בעיקר את אותם מעטים
אנשים שמנסים לחדד את מיפויי ה-CWE של מבחן הפגמים או לשכלל את ה-CWE באופן כללי.
קוד המקור מתעד את המיפוי בין רכיבי האבטחה ל-CWE המתאים
מזהים, והוא קובץ Python יחיד. מערך הנתונים ``c_rules'' מגדיר את רוב הכללים,
בהתייחס לפונקציה שעשויה לבצע חידודים נוספים. אתה יכול לחפש את
מערך נתונים עבור שמות פונקציות כדי לראות איזה CWE הוא מייצר כברירת מחדל; אם הפרמטר הראשון הוא
לא ``נורמלי'' אז זה השם של שיטת פייתון זיקוק שעשויה לבחור אחרת
CWEs (בהתאם למידע נוסף). לעומת זאת, אתה יכול לחפש ``מספר CWE''
ומצא אילו רכיבי אבטחה (חתימות או דפוסים) מתייחסים לאותו מזהה CWE.
עבור רוב האנשים, זה הרבה יותר ממה שהם צריכים; רוב האנשים פשוט רוצים לסרוק את שלהם
קוד מקור כדי למצוא בעיות במהירות.

אבטחה

כל העניין של הכלי הזה הוא לעזור למצוא נקודות תורפה כדי שניתן יהיה לתקן אותן.
עם זאת, מפתחים ומבקרים חייבים לדעת כיצד לפתח תוכנה מאובטחת כדי להשתמש בזה
כלי, כי אחרת, a לרמות עם a כלי is עוד a לרמות. הספר שלי ב
http://www.dwheeler.com/secure-programs יכול לעזור.

כלי זה צריך להיות, לכל היותר, חלק קטן מתהליך פיתוח תוכנה גדול יותר
נועד לחסל או להפחית את ההשפעה של פגיעויות. מפתחים ומבקרים
צריכים לדעת איך לפתח תוכנה מאובטחת, והם צריכים ליישם את הידע הזה כדי להפחית
את הסיכונים של פגיעות מלכתחילה.

כלים שונים לאיתור פגיעות נוטים למצוא פגיעויות שונות. לפיכך, אתה
עדיף להשתמש בסקירה אנושית ובמגוון כלים. כלי זה יכול לעזור למצוא כמה
פגיעות, אבל בשום פנים ואופן לא את כולם.

תמיד כדאי לנתח את א העתק של תוכנית המקור המנותחת, לא ספריה
זה יכול להיות שונה על ידי מפתח בזמן ש-flawfinder מבצע את הניתוח. זה
במיוחד נכון אם אתה לא בהכרח סומך על מפתח של התוכנית המנותחת.
אם לתוקף יש שליטה על הקבצים בזמן שאתה מנתח אותם, התוקף יכול
להעביר קבצים או לשנות את תוכנם כדי למנוע חשיפה של בעיית אבטחה
(או ליצור רושם של בעיה שבה אין). אם אתה מודאג
מתכנתים זדוניים אתה צריך לעשות זאת בכל מקרה, כי לאחר ניתוח תצטרך לעשות זאת
ודא שהקוד שרץ בסופו של דבר הוא הקוד שניתחת. כמו כן, אל תשתמש ב
--אפשרות קישור במקרים כאלה; תוקפים עלולים ליצור קישורים סמליים זדוניים לקבצים
מחוץ לאזור קוד המקור שלהם (כגון / etc / passwd).

מערכות ניהול קוד מקור (כמו SourceForge ו-Savannah) בהחלט נופלות בזה
קטגוריה; אם אתה מתחזק אחת מהמערכות האלה, תחילה העתק או חלץ את הקבצים לתוכם
ספרייה נפרדת (שלא ניתן לשלוט בה על ידי תוקפים) לפני הפעלת Flawfinder או
כל כלי אחר לניתוח קוד.

שים לב ש-flawfinder פותח רק קבצים רגילים, ספריות וסמליות (אם מתבקשים).
קישורים; הוא לעולם לא יפתח סוגים אחרים של קבצים, גם אם נוצר אליהם קישור סמלי.
זה נוגד תוקפים שמכניסים סוגי קבצים חריגים לקוד המקור. עם זאת, זה
עובד רק אם מערכת הקבצים המנותחת לא ניתנת לשינוי על ידי תוקף במהלך
ניתוח, כפי שהומלץ לעיל. ההגנה הזו גם לא עובדת על פלטפורמות Cygwin,
לצערי.

למערכות Cygwin (אמולציית Unix על גבי Windows) יש בעיה נוספת אם מוצאים פגמים
משמש לניתוח תוכניות שהאנליסט אינו יכול לסמוך עליהן. הבעיה נובעת מעיצוב
פגם ב-Windows (שהיא יורשת מ-MS-DOS). ב-Windows וב-MS-DOS, שמות קבצים מסוימים
(למשל, ``com1'') מטופלים באופן אוטומטי על ידי מערכת ההפעלה כשמות של
ציוד היקפי, וזה נכון גם כאשר ניתן שם נתיב מלא. כן, Windows ו-MS-DOS
באמת מעוצבים כל כך גרוע. Flawfinder מתמודד עם זה על ידי בדיקת איזו מערכת קבצים
האובייקט הוא, ולאחר מכן רק פתיחת ספריות וקבצים רגילים (וקישורים סימליים אם מופעלים).
למרבה הצער, זה לא עובד על Cygwin; לפחות בחלק מהגרסאות של Cygwin בחלק מהן
גרסאות של Windows, רק ניסיון לקבוע אם קובץ הוא מסוג התקן יכול לגרום ל
תוכנית לתלייה. דרך לעקיפת הבעיה היא למחוק או לשנות את השם של כל שמות קבצים שמתפרשים
כשמות מכשירים לפני ביצוע הניתוח. אלה שנקראים ``שמות שמורים'' הם
CON, PRN, AUX, CLOCK$, NUL, COM1-COM9 ו-LPT1-LPT9, אופציונלי ואחריהם הרחבה
(למשל, ``com1.txt''), בכל ספרייה, ובכל מקרה (Windows אינו תלוי רישיות).

Do לֹא טען או הבדל רשימות התאמה ממקורות לא מהימנים. הם מיושמים באמצעות ה
מודול החמוצים של Python, ומודול החמוצים לא נועד להיות מאובטח מפני שגיאות
או נתונים שנבנו בזדון. רשימות היט מאוחסנות מיועדות לשימוש מאוחר יותר על ידי אותו
משתמש שיצר את רשימת ההיט; בהקשר זה הגבלה זו אינה מהווה בעיה.

השתמש ב-Flawfinder באינטרנט באמצעות שירותי onworks.net