הגדרת מאפייני שפה של כללים מותאמים אישית

לכל כלל במדיניות האבטחה של Google Cloud Armor יש עדיפות, תנאי התאמה ופעולה. ‫Cloud Armor מבצע את הפעולה של הכלל עם העדיפות הכי גבוהה שתואם לבקשה. המערכת לא בודקת כללים עם עדיפות נמוכה יותר מהכלל התואם עם העדיפות הכי גבוהה, גם אם יש להם את אותם תנאי התאמה.

כל כלל במדיניות האבטחה תומך בשני סוגים של תנאי התאמה:

תנאי התאמה בסיסי מכיל רשימות של כתובות IP או רשימות של טווחי כתובות IP. כשיוצרים כלל באמצעות Google Cloud CLI, מגדירים תנאי התאמה בסיסיים באמצעות הדגל --src-ip-ranges.
תנאי מתקדם להתאמה מכיל ביטוי עם עד חמישה ביטויי משנה שיכולים להתאים למגוון מאפיינים של בקשה נכנסת. תנאי התאמה מתקדמים מוגדרים באמצעות הדגל --expression כשיוצרים כלל באמצעות Google Cloud CLI.

בדף הזה נסביר על תנאי התאמה מתקדמים ועל שפת הכללים המותאמים אישית של Cloud Armor, שמשמשת לכתיבת ביטויים בתנאי ההתאמה המתקדמים של כללי מדיניות האבטחה. השפה של הכללים בהתאמה אישית ב-Cloud Armor היא קבוצת משנה של Common Expression Language ‏(CEL). ביטויים שנכתבים בשפה של כללים בהתאמה אישית ב-Cloud Armor דורשים שני רכיבים:

המאפיין: הנתונים לבדיקה
הפעולה: איך משתמשים בנתונים

לדוגמה, הביטוי הבא משתמש במאפיינים origin.ip ו-9.9.9.0/24 בפעולה inIpRange(). במקרה הזה, הביטוי מחזיר True אם origin.ip נמצא בטווח כתובות ה-IP‏ 9.9.9.0/24.

inIpRange(origin.ip, '9.9.9.0/24')

למרות שביטוי הדוגמה הקודם תואם רק לכתובת ה-IP של הלקוח, כשמשתמשים בביטוי הדוגמה בכלל של מדיניות אבטחה של Cloud Armor, הכלל נחשב לכלל עם תנאי התאמה מתקדמים מבחינת מכסת השימוש. מידע נוסף מופיע במאמר בנושא מכסות ומגבלות של Cloud Armor.

תפעול

במאמר הבא מוסבר על האופרטורים שאפשר להשתמש בהם עם מאפיינים (שמיוצגים על ידי x,‏ y ו-k) כדי להגדיר ביטויי כללים.

תפעול	ביטויים	תיאור
שוויון	`x == y`	הפונקציה מחזירה את הערך True אם x שווה ל-y.
שוויון, מחרוזת מילולית	`x == "foo"`	הפונקציה מחזירה את הערך True אם x שווה למחרוזת הקבועה שצוינה.
שוויון, מחרוזת גולמית מילולית	`x == R"fo'o"`	הפונקציה מחזירה את הערך True אם x שווה למחרוזת הליטרלית הגולמית שצוינה, שלא מפרשת רצפי escape. ליטרלים של מחרוזות גולמיות נוחים לשימוש כשצריך להשתמש בתווי בריחה כדי לייצג מחרוזות.
שלילה לוגית	`!x`	הפונקציה מחזירה את הערך True אם הערך הבוליאני x הוא False, או מחזירה את הערך False אם הערך הבוליאני x הוא True.
אי-שוויון	`x != y`	הפונקציה מחזירה את הערך True אם x לא שווה ל-y.
שרשור	`x + y`	הפונקציה מחזירה את המחרוזת המחוברת xy.
וגם לוגי	`x && y`	הפונקציה מחזירה את הערך True אם גם x וגם y נכונים.
OR לוגי	`x \|\| y`	הפונקציה מחזירה את הערך True אם x,‏ y או שניהם נכונים.
מכיל מחרוזת משנה	`x.contains(y)`	הפונקציה מחזירה את הערך True אם המחרוזת x מכילה את מחרוזת המשנה y.
מתחיל עם מחרוזת משנה	`x.startsWith(y)`	הפונקציה מחזירה את הערך True אם המחרוזת x מתחילה במחרוזת המשנה y.
מסתיים במחרוזת משנה	`x.endsWith(y)`	הפונקציה מחזירה את הערך True אם המחרוזת x מסתיימת במחרוזת המשנה y.
התאמה של ביטוי רגיל	`x.matches(y)`	הפונקציה מחזירה את הערך True אם המחרוזת x תואמת באופן חלקי לתבנית y שצוינה של RE2. התבנית RE2 עוברת קומפילציה באמצעות האפשרות RE2::Latin1 שמשביתה תכונות Unicode.
כתובת IP בטווח	`inIpRange(x, y)`	הפונקציה מחזירה את הערך True אם כתובת ה-IP‏ x כלולה בטווח כתובות ה-IP‏ y.
אותיות קטנות	`x.lower()`	הפונקציה מחזירה את הערך באותיות קטנות של המחרוזת x.
אותיות רישיות	`x.upper()`	הפונקציה מחזירה את הערך באותיות רישיות של המחרוזת x.
ערך מפוענח בקידוד Base64	`x.base64Decode()`	הפונקציה מחזירה את הערך המפוענח של x בקידוד base64. התווים `_ -` מוחלפים קודם ב-`/ +` בהתאמה. הפונקציה מחזירה `""` (מחרוזת ריקה) אם x הוא לא ערך Base64 תקין.
ערך של מיפוי מקשים	`m['k']`	הפונקציה מחזירה את הערך במפתח k במפה m של מחרוזת למחרוזת אם k זמין. אחרת, הפונקציה מחזירה שגיאה. הגישה המומלצת היא קודם לבדוק את הזמינות באמצעות `"has(m['k'])==true"`.
בדיקת הזמינות של מפתחות במפה	`has(m['k'])`	הפונקציה מחזירה את הערך True אם המפתח k זמין במפה m.
המרה למספר שלם	`int(x)`	הפונקציה ממירה את תוצאת המחרוזת של x לסוג `int`. אחר כך אפשר להשתמש בו כדי לבצע השוואה בין מספרים שלמים באמצעות אופרטורים אריתמטיים רגילים כמו > ו-<=. הפעולה הזו אפשרית רק עבור ערכים שאמורים להיות מספרים שלמים.
אורך	`size(x)`	הפונקציה מחזירה את האורך של המחרוזת x.
פענוח כתובת URL	`x.urlDecode()`	הפונקציה מחזירה את הערך של x אחרי פענוח כתובת ה-URL. רצפי תווים בפורמט `%##` מוחלפים במקבילות שאינן ASCII, ו-`+` מוחלף ברווח. קידודים לא תקינים מוחזרים כמו שהם.
פענוח כתובת URL (Unicode)	`x.urlDecodeUni()`	הפונקציה מחזירה את הערך של x אחרי פענוח כתובת ה-URL. בנוסף ל-`urlDecode()`, היא מטפלת גם ברצפים של תווים ב-Unicode בפורמט `%u###`. קידודים לא תקינים מוחזרים כמו שהם.
המרת utf8 ל-Unicode	`x.utf8ToUnicode()`	הפונקציה מחזירה את הייצוג ב-Unicode של אותיות קטנות בקידוד UTF-8 של x.

מאפיינים

מאפיינים מייצגים מידע מבקשה נכנסת, כמו כתובת ה-IP של הלקוח או נתיב כתובת ה-URL המבוקשת.

שדה	סוג	תיאור
`origin.ip`	מחרוזת	כתובת ה-IP של הלקוח שיזם את הבקשה.
`origin.user_ip`	מחרוזת	כתובת ה-IP של הלקוח המקורי, שנכללת ב-`HTTP-HEADER` על ידי שרת Proxy במעלה הזרם. לפני שמשתמשים במאפיין הזה, צריך להגדיר את האפשרות `userIpRequestHeaders[]` בשדה `advancedOptionsConfig` של מדיניות האבטחה כך שתתאים למקור כמו `True-Client-IP`,‏ `X-Forwarded-For` או `X-Real-IP`. מידע נוסף זמין במאמר בנושא סקירה כללית של כתובות ה-IP של משתמשים. אם לא מגדירים את האפשרות `userIpRequestHeaders[]`, אם הכותרת שהוגדרה מכילה ערכים לא חוקיים של כתובות IP או אם הכותרת שהוגדרה לא קיימת, ברירת המחדל של `origin.user_ip` היא `origin.ip`. מידע נוסף זמין במאמר בנושא securityPolicy.
`origin.tls_ja4_fingerprint`	מחרוזת	טביעת אצבע של JA4 TLS/SSL אם הלקוח מתחבר באמצעות ‫`HTTPS`, `HTTP/2` או `HTTP/3`. אם הוא לא זמין, מוחזרת מחרוזת ריקה.
`origin.tls_ja3_fingerprint`	מחרוזת	טביעת אצבע של JA3 TLS/SSL אם הלקוח מתחבר באמצעות ‫`HTTPS`, `HTTP/2` או `HTTP/3`. אם הוא לא זמין, מוחזרת מחרוזת ריקה.
`request.headers`	מפה	מיפוי של כותרות בקשת HTTP ממחרוזת למחרוזת. אם כותרת מכילה כמה ערכים, הערך במפה הזו יהיה מחרוזת מופרדת בפסיקים של כל הערכים של הכותרת. כל המפתחות במפה הזו הם אותיות קטנות. כל הכותרות שמתקבלות על ידי מאזני עומסים חיצוניים של אפליקציות נבדקות, וחלות עליהן אותן הגבלות. הגישה המומלצת היא קודם לבדוק את הזמינות באמצעות `has()`, כמו `has(request.headers['header-key']) && request.headers['header-key'] != 'header-value'`.
`request.method`	מחרוזת	ה-method של בקשת ה-HTTP.
`request.path`	מחרוזת	נתיב כתובת ה-URL מסוג HTTP שהתבקש. כשכותבים כללים שמתאימים ל-`request.path`, מומלץ לבצע נורמליזציה של הנתיב כדי להקל על התאמת התחביר במקרה של קידוד כתובת URL, וריאציות של אותיות רישיות או לוכסנים הפוכים. מידע נוסף ודוגמאות זמינים במאמר בנושא Path traversal and normalization (מעבר בין נתיבים ונרמול).
`request.scheme`	מחרוזת	סכימת כתובת ה-URL מסוג HTTP, כמו `http` או `https`. הערכים של המאפיין הזה הם באותיות קטנות.
`request.query`	מחרוזת	שאילתת כתובת URL מסוג HTTP בפורמט `name1=value&name2=value2`, כפי שהיא מופיעה בשורה הראשונה של בקשת ה-HTTP. לא מתבצע פענוח.
`origin.region_code`	מחרוזת	קוד המדינה ב-Unicode שמשויך לכתובת ה-IP של הלקוח, לדוגמה `US`. אם יוצרים כלל או ביטוי שמשתמשים בקודי מדינה או אזור לפי ISO 3166-1 alpha 2, ‏ Cloud Armor מתייחס לכל קוד בנפרד. הכללים והביטויים של Cloud Armor משתמשים בקודים האזוריים האלה באופן מפורש כדי לאשר או לדחות בקשות.
`origin.asn`	מספר שלם	מספר המערכת האוטונומית (ASN) שמשויך לכתובת ה-IP של הלקוח. מספר ה-ASN הייחודי הגלובלי נקבע על סמך מפעיל הרשת שתומך בקידומות של כתובות ה-IP שמכילות את כתובת ה-IP של הלקוח.

מאפייני reCAPTCHA

בקטע הזה מפורטים מאפיינים שרלוונטיים רק לטוקנים של reCAPTCHA או לקובצי Cookie של פטור. ביטוי משנה שמבוסס על המאפיינים האלה מחזיר false אם טוקן reCAPTCHA או קובץ Cookie של פטור להערכה לא זמינים או לא תקינים בגלל אחת מהסיבות הבאות:

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

מאפייני עוגיית הפטור

שדה	סוג	תיאור
`token.recaptcha_exemption.valid`	`bool`	קובץ Cookie תקף של פטור מ-reCAPTCHA.

מאפיינים של טוקן פעולה

שדה	סוג	תיאור
`token.recaptcha_action.score`	`float`	הציון מטוקן פעולה של reCAPTCHA. הניקוד התקין נע בין `0.0` ל-`1.0`, כאשר `0.0` מציין משתמש לא לגיטימי ו-`1.0` מציין משתמש לגיטימי.
`token.recaptcha_action.captcha_status`	`string`	סטטוס ה-CAPTCHA מטוקן פעולה של reCAPTCHA. סטטוס תקין הוא `NONE`, `PASS` או `FAIL`, כאשר `NONE` מתייחס למצב שבו לא נדרש אתגר במהלך בדיקת reCAPTCHA, כך ששדה ה-CAPTCHA חסר בטוקן הפעולה.
`token.recaptcha_action.action`	`string`	שם הפעולה (עד 100 תווים) מטוקן פעולה של reCAPTCHA. שמות הפעולות
`token.recaptcha_action.valid`	`bool`	נוכחות של טוקן פעולה תקין של reCAPTCHA.

מאפיינים של טוקן הסשן

שדה	סוג	תיאור
`token.recaptcha_session.score`	`float`	הציון מאסימון הפעלה של reCAPTCHA. הניקוד התקין נע בין `0.0` ל-`1.0`, כאשר `0.0` מציין משתמש לא לגיטימי ו-`1.0` מציין משתמש לגיטימי.
`token.recaptcha_session.valid`	`bool`	נוכחות של טוקן תקף של סשן reCAPTCHA.

ביטויים לדוגמה

עבור כל אחד מהביטויים האלה, הפעולה שתתבצע תלויה בשאלה אם הביטוי נכלל בכלל דחייה או בכלל הרשאה.

אישור או דחייה של גישה על סמך טווח כתובות IP ב-IPv4 או ב-IPv6

הביטוי הבא תואם לבקשות מטווח כתובות ה-IP‏: 198.51.100.0/24
```
inIpRange(origin.ip, '198.51.100.0/24')
```
הביטוי הבא תואם לבקשות מטווח כתובות ה-IP‏: 2001:db8::/32
```
inIpRange(origin.ip, '2001:db8::/32')
```

אישור או דחייה של גישה על סמך טווח כתובות IP מותאם אישית של לקוחות מאחורי שרת proxy במעלה הזרם

אם הגדרתם את האופרטור origin.user_ip, תוכלו להתאים על סמך ערכי הכותרת שציינתם בשדה advancedOptionsConfig.userIpRequestHeaders[].

הביטוי הבא תואם לבקשות שמקורן בטווח כתובות ה-IP‏ 192.0.2.0/24:
```
inIpRange(origin.user_ip, '192.0.2.0/24')
```
הביטוי הבא תואם לבקשות שמקורן בטווח כתובות ה-IP‏ 2001:db8::/32:
```
inIpRange(origin.user_ip, '2001:db8::/32')
```

אישור או דחייה של תעבורה עם קובץ Cookie ספציפי

הביטוי הבא תואם לבקשות שיש להן קובץ Cookie שמכיל את הערך 80=BLAH:
```
has(request.headers['cookie']) && request.headers['cookie'].contains('80=BLAH')
```

אישור או דחייה של תנועת גולשים עם כותרת `referer` לא ריקה

הביטוי הבא תואם לבקשות עם כותרת referer לא ריקה:
```
has(request.headers['referer']) && request.headers['referer'] != ""
```

אישור או דחייה של תנועה על סמך כותרת המארח

אפשר לאשר או לדחות תנועה על סמך הערך של הכותרת Host בבקשה.

הביטוי הבא תואם לבקשות לכתובת URL ספציפית באמצעות ==:
```
request.headers['host'].lower() == 'test.example.com'
```
הביטוי הבא תואם לבקשות לכתובת URL ספציפית באמצעות endsWith:
```
request.headers['host'].lower().endsWith('.example.com')
```
הביטוי הבא תואם לבקשות לכתובת URL ספציפית באמצעות contains:
```
request.headers['host'].lower().contains('test.example.com')
```

הביטוי הבא תואם לבקשות למספר דומיינים באמצעות contains:

request.headers['host'].lower().contains('test.example.com') || request.headers['host'].lower().contains('test22.example.com')

הביטוי הבא תואם לבקשות לדומיין ולתת-הדומיינים שלו באמצעות matches:
```
request.headers['host'].matches('(?i:(sub\.)?test\.example\.com)')
```

אישור או דחייה של תנועה מאזור ספציפי

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

בכלל דחייה, משתמשים בביטוי הבא שתואם לבקשות מהאזור AU:
```
origin.region_code == 'AU'
```

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

בכלל דחייה, משתמשים בביטוי הבא, שתואם לבקשות מכל האזורים מלבד אזור AU:
```
origin.region_code != 'AU'
```

קודי האזורים מבוססים על קודי ISO 3166-1 alpha 2. לפעמים אזור מתאים למדינה, אבל זה לא תמיד המצב. לדוגמה, הקוד US כולל את כל המדינות בארצות הברית, מחוז אחד ושישה אזורים מרוחקים.

אישור או דחייה של תנועה ממספר מערכת אוטונומית (ASN) ספציפי

אם אתם צריכים לחסום את אפליקציית האינטרנט שלכם ללקוחות שמקבלים שירות מספק רשת ספציפי, אתם יכולים להשתמש במספר ה-ASN של ספק הרשת כדי לחסום אותה.

בכלל דחייה, משתמשים בביטוי הבא, שתואם לבקשות מ-ASN ספציפי:
```
origin.asn == 123
```

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

בכלל דחייה, משתמשים בביטוי הבא, שתואם לכל מפעילי הרשתות האחרים מלבד זה שרוצים לאפשר:
```
origin.asn != 123
```

כמה ביטויים

כדי לכלול כמה תנאים בכלל אחד, משלבים כמה ביטויי משנה.

בדוגמה הבאה, בקשות מ-1.2.3.0/24 (למשל, בודקי אלפא) באזור AU תואמות לביטוי הבא:
```
origin.region_code == "AU" && inIpRange(origin.ip, '1.2.3.0/24')
```

הביטוי הבא תואם לבקשות מ-1.2.3.4 שבהן סוכן המשתמש מכיל את המחרוזת WordPress:

inIpRange(origin.ip, '1.2.3.4/32') &&
has(request.headers['user-agent']) && request.headers['user-agent'].contains('WordPress')

אישור או דחייה של תנועה עבור URI של בקשה שתואם לביטוי רגולרי

הביטוי הבא תואם לבקשות שמכילות את המחרוזת /example_path/ במזהה ה-URI:
```
request.path.matches('/example_path/')
```
הביטוי הבא תואם לבקשות שכוללות את Chrome בשדה הכותרת User-Agent:
```
request.headers['user-agent'].matches('Chrome')
```
הביטוי הבא מציג התאמה לא תלוית-אותיות בכותרת User-Agent שמכילה את wordpress. הוא מתאים ל-User-Agent:WordPress/605.1.15, ל-User-Agent:wordPress ולוריאציות אחרות של wordpress:
```
request.headers['user-agent'].matches('(?i:wordpress)')
```

התרת תנועה שמכילה ערך מפוענח ספציפי בקידוד base64 או דחיית תנועה כזו

הביטוי הבא תואם לבקשות עם ערך מפוענח ב-Base64 של myValue בכותרת user-id:
```
has(request.headers['user-id']) && request.headers['user-id'].base64Decode().contains('myValue')
```

אישור או דחייה של תנועה שמכילה ערך מחרוזת באורך מסוים

הביטוי הבא תואם לבקשות שבהן אורך כתובת ה-URL גדול מ-10 תווים:
```
size(request.path) > 10
```
הביטוי הבא תואם לבקשות עם כותרת x-data באורך של 1,024 תווים או יותר:
```
size(request.headers['x-data']) >= 1024
```

התרת תנועה או דחייה של תנועה עם 0 `content-length` בגוף ה-HTTP

הביטוי הבא תואם לבקשות שכוללות אפס content-length בגוף ה-HTTP:
```
int(request.headers["content-length"]) == 0
```

אישור או דחייה של תנועה שמכילה ערך מקודד ספציפי של כתובת URL

הביטוי הבא תואם לבקשות עם ערך של קובץ Cookie שמכיל %3c:
```
has(request.headers['cookie']) && request.headers['cookie'].urlDecode().contains('<')
```

אישור או דחייה של תנועה שמכילה ערך מקודד ספציפי של כתובת URL של מחרוזת Unicode

הביטוי הבא תואם לבקשות שכוללות ערך של קובץ Cookie ששווה ל-Match%2BValue או ל-Match%u002BValue:
```
has(request.headers['cookie']) && request.headers['cookie'].urlDecodeUni() == 'Match+Value'
```

אישור או דחייה של תנועה שמכילה מחרוזת Unicode ספציפית של טקסט UTF-8

הביטוי הבא תואם לבקשות שבהן ערך קובץ ה-Cookie שווה ל-¬:
```
has(request.headers['cookie']) && request.headers['cookie'].utf8ToUnicode() == '%u00ac'
```

אישור או דחייה של תנועה על סמך טביעת אצבע מוכרת של JA4

הביטוי הבא תואם לבקשות עם טביעת אצבע של JA4 ששווה ל-t13d1516h2_8daaf6152771_b186095e22b6:
```
origin.tls_ja4_fingerprint == 't13d1516h2_8daaf6152771_b186095e22b6'
```

אישור או דחייה של תנועה על סמך רשימה של טביעות אצבע של JA4

הביטוי הבא תואם לבקשות עם טביעת אצבע של JA4 ששווה לאחת מטביעות האצבע הבאות של JA4:
- t00d0000h0_000000000000_000000000000
- t13d1516h2_8daaf6152771_b186095e22b6
```
origin.tls_ja4_fingerprint == 't00d0000h0_000000000000_000000000000' || origin.tls_ja4_fingerprint == 't13d1516h2_8daaf6152771_b186095e22b6'
```

כללי WAF שהוגדרו מראש

כללי WAF שהוגדרו מראש משתמשים בחתימות סטטיות שהוגדרו מראש, בביטויים רגולריים או בשניהם כדי להתאים לגוף הבקשה של HTTP, לכותרות הבקשה של HTTP ולפרמטרים של שאילתה. הכללים הזמינים של חומת האפליקציות האינטרנטיות שהוגדרו מראש מבוססים על קבוצת הכללים המרכזית של OWASP בגרסה 3.3. ב-Cloud Armor יש כמה כללי WAF מוגדרים מראש. רשימה מלאה של כללי WAF שהוגדרו מראש זמינה במאמר בנושא סקירה כללית של כללי WAF שהוגדרו מראש ב-Cloud Armor.

כדי לראות רשימה של כל כללי ה-WAF המוגדרים מראש, אפשר לעיין במאמר בנושא רשימת כללי WAF מוגדרים מראש.

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

שמות של כללי WAF שהוגדרו מראש

השמות של כללי WAF שהוגדרו מראש הם בפורמט <attack category>-<OWASP CRS version>-<version field>. קטגוריית ההתקפה מציינת את סוג ההתקפות שרוצים להגן מפניהן, כמו xss (פרצת אבטחה XSS‏ (cross-site scripting)) או sqli (הזרקת SQL).

שדות הגרסה הנתמכים הם stable ו-canary. תוספות ושינויים בכללים מתפרסמים קודם בגרסה canary. כאשר תוספות ושינויים נחשבים בטוחים ויציבים, הם מקודמים לגרסה stable.

מזהים של חברים בכלל WAF שהוגדרו מראש

כלל WAF שהוגדר מראש מכיל כמה ביטויים, שלכל אחד מהם יש חתימה משלו. לדוגמה, כלל ה-WAF שהוגדר מראש xss-v33-stable כולל ביטוי שנקרא owasp-crs-v030301-id941100-xss, שמתאים למזהה הכלל id941100 בגרסה 3.3. אתם יכולים להשתמש בחתימות כדי להחריג ביטויים ספציפיים, וכך למנוע את השימוש בהם. זה שימושי אם ביטוי מסוים מפעיל באופן עקבי תוצאה חיובית שגויה. מידע נוסף זמין במאמר בנושא תוצאות חיוביות שגויות.

מידע על ערכת הכללים הבסיסית ועל שינוי ההגדרות ברמות רגישות שונות זמין במאמר שינוי ההגדרות של כללי WAF ב-Google Cloud Armor.

אופרטור לכללי WAF שהוגדרו מראש

ביטויים תיאור

ביטויים	תיאור
`evaluatePreconfiguredWaf(string, MAP<string, dyn>)`	הפונקציה מחזירה true אם אחת מחתימות ה-WAF בתוך קבוצת כללי ה-WAF שצוינה מחזירה true. הארגומנט הראשון הוא השם של קבוצת הכללים של ה-WAF, למשל `xss-v33-stable`. הארגומנט השני (אופציונלי) הוא מיפוי שבו המפתח הוא מחרוזת והערך הוא הקלדה דינמית בהתאם למפתח. מטרת הארגומנט הזה היא לכוונן את החתימות של ה-WAF שמוערכות. המפתחות הקבילים כוללים את: ‫'sensitivity': התכונה הזו תואמת לרמת הפרנויה של OWASP Core Rule Set, שיש לה 4 רמות, מ-1 עד 4. הערך שלו הוא מספר שלם עם טווח חוקי מ-0 עד 4. הערה: הערך 0 שמור כערך תקין כשמשתמשים בו בשילוב עם opt_in_rule_ids (שמתואר בהמשך). כשמציינים רמת רגישות x (x >= 1), כל החתימות המשויכות של WAF עם ערך רגישות מ-1 עד x מוערכות. אם לא מציינים ערך, המערכת משתמשת בערך הרגישות 4. ‫"opt_out_rule_ids": חתימות של WAF (מיוצגות על ידי מזהי כללים) שרוצים להחריג מההערכה, כאשר קבוצת הבסיס נקבעת לפי ערך הרגישות. הערך שלו הוא רשימה של מחרוזות. המספר המקסימלי של מזהי כללים שמותר להזין הוא `128`. ‫opt_in_rule_ids: חתימות של WAF (מיוצגות על ידי מזהי כללים) שצריך להפעיל כדי לבצע הערכה, כאשר קבוצת הבסיס ריקה. הערך שלו הוא רשימה של מחרוזות. המספר המקסימלי של מזהי כללים שמותר להזין הוא `128`. כשמשתמשים בזה, צריך לציין את רמת הרגישות `0`. המפתחות opt_out_rule_ids ו-opt_in_rule_ids הם בלעדיים. אתם יכולים להשתמש ב-opt_in_rule_ids אם אתם רוצים לבדוק ולצרף באופן ידני חתימות חדשות של WAF שנוספו מאוחר יותר לקבוצת כללים קיימת.
`evaluatePreconfiguredExpr(string, LIST)`	שימו לב: האפשרות `evaluatePreconfiguredExpr()` הוצאה משימוש. מומלץ להשתמש ב-`evaluatePreconfiguredWaf()` במקום זאת. הפונקציה מחזירה true אם אחד מהביטויים בתוך כלל ה-WAF שצוין מראש מחזיר true. הארגומנט הראשון הוא השם של כלל ה-WAF שהוגדר מראש, למשל `xss-stable`. הארגומנט השני (אופציונלי) הוא רשימה של מזהים שמופרדים בפסיקים, שצריך להחריג מההערכה. רשימת ההחרגות שימושית כשחבר מסוים בכלל WAF שהוגדר מראש מפעיל תוצאת חיובית שגויה.

evaluatePreconfiguredWaf(string, MAP<string, dyn>)

הפונקציה מחזירה true אם אחת מחתימות ה-WAF בתוך קבוצת כללי ה-WAF שצוינה מחזירה true. הארגומנט הראשון הוא השם של קבוצת הכללים של ה-WAF, למשל xss-v33-stable. הארגומנט השני (אופציונלי) הוא מיפוי שבו המפתח הוא מחרוזת והערך הוא הקלדה דינמית בהתאם למפתח. מטרת הארגומנט הזה היא לכוונן את החתימות של ה-WAF שמוערכות. המפתחות הקבילים כוללים את:

‫'sensitivity': התכונה הזו תואמת לרמת הפרנויה של OWASP Core Rule Set, שיש לה 4 רמות, מ-1 עד 4. הערך שלו הוא מספר שלם עם טווח חוקי מ-0 עד 4. הערה: הערך 0 שמור כערך תקין כשמשתמשים בו בשילוב עם opt_in_rule_ids (שמתואר בהמשך). כשמציינים רמת רגישות x (x >= 1), כל החתימות המשויכות של WAF עם ערך רגישות מ-1 עד x מוערכות. אם לא מציינים ערך, המערכת משתמשת בערך הרגישות 4.
‫"opt_out_rule_ids": חתימות של WAF (מיוצגות על ידי מזהי כללים) שרוצים להחריג מההערכה, כאשר קבוצת הבסיס נקבעת לפי ערך הרגישות. הערך שלו הוא רשימה של מחרוזות. המספר המקסימלי של מזהי כללים שמותר להזין הוא 128.
‫opt_in_rule_ids: חתימות של WAF (מיוצגות על ידי מזהי כללים) שצריך להפעיל כדי לבצע הערכה, כאשר קבוצת הבסיס ריקה. הערך שלו הוא רשימה של מחרוזות. המספר המקסימלי של מזהי כללים שמותר להזין הוא 128. כשמשתמשים בזה, צריך לציין את רמת הרגישות 0.

המפתחות opt_out_rule_ids ו-opt_in_rule_ids הם בלעדיים. אתם יכולים להשתמש ב-opt_in_rule_ids אם אתם רוצים לבדוק ולצרף באופן ידני חתימות חדשות של WAF שנוספו מאוחר יותר לקבוצת כללים קיימת.

evaluatePreconfiguredExpr(string, LIST)

שימו לב: האפשרות evaluatePreconfiguredExpr() הוצאה משימוש. מומלץ להשתמש ב-evaluatePreconfiguredWaf() במקום זאת.

הפונקציה מחזירה true אם אחד מהביטויים בתוך כלל ה-WAF שצוין מראש מחזיר true.

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

דוגמאות לכללי WAF שהוגדרו מראש

הביטוי הבא משתמש בכלל WAF שהוגדר מראש xss-v33-stable כדי לצמצם את הסיכון להתקפות XSS:
```
evaluatePreconfiguredWaf('xss-v33-stable')
```
הביטוי הבא משתמש בכל הביטויים מכלל ה-WAF שהוגדר מראש xss-v33-stable, חוץ ממזהי החברים 941100 ו-941110:
```
evaluatePreconfiguredWaf('xss-v33-stable', {'opt_out_rule_ids': ['owasp-crs-v030301-id941100-xss',
'owasp-crs-v030301-id941110-xss']})
```
הביטוי הבא משתמש בכלל WAF שהוגדר מראש כדי לצמצם את ההשפעה של מתקפות SQLi מטווח כתובות ה-IP‏ 198.51.100.0/24:
```
inIpRange(origin.ip, '198.51.100.0/24') && evaluatePreconfiguredWaf('sqli-v33-stable')
```

אופרטורים אחרים

ביטויים	תיאור
`evaluateThreatIntelligence(string)` `evaluateThreatIntelligence(string, LIST)` `evaluateThreatIntelligence(string, string, LIST)`	הפונקציה מחזירה True אם כתובת ה-IP של הלקוח תואמת לטווח כתובות IP כלשהו ברשימת כתובות ה-IP שצוינה, אלא אם היא הוחרגה במפורש באמצעות רשימת ההחרגות. הארגומנט הראשון הוא השם של פיד המידע של Google Threat Intelligence, כמו `iplist-known-malicious-ips`. אם הארגומנט השני הוא מחרוזת (אופציונלי), הוא קובע מאיפה כתובת ה-IP מחולצת, והוא יכול להיות `origin.ip`,‏ `origin.user_ip` או שם של כותרת ספציפית. אם הארגומנט השני או השלישי (אופציונלי) הוא רשימה של מחרוזות שמופרדות באמצעות פסיקים, כאשר כל מחרוזת היא כתובת IP או טווח CIDR, הכתובת או הטווח האלה יוחרגו מההערכה. רשימת ההחרגות שימושית אם פיד מכיל כתובת IP שמפעילה תוצאה חיובית שקרית. הערה: כשמשתמשים ב-`origin.user_ip`, צריך להגדיר את האפשרות `userIpRequestHeaders[]` בשדה `advancedOptionsConfig` של מדיניות האבטחה.
`evaluateAddressGroup(string, string)` `evaluateAddressGroup(string, string, LIST)` `evaluateOrganizationAddressGroup(string, string)` `evaluateOrganizationAddressGroup(string, string, LIST)`	הפונקציה מחזירה את הערך True אם כתובת ה-IP של הלקוח תואמת לאחד מטווח כתובות ה-IP בקבוצת הכתובות שצוינה, אלא אם היא הוחרגה באופן מפורש באמצעות רשימת ההחרגות. הארגומנט הראשון הוא שם קבוצת הכתובות. הארגומנט השני קובע מאיפה כתובת ה-IP מחולצת, והוא יכול להיות `origin.ip`, `origin.user_ip` או שם של כותרת ספציפית. הארגומנט השלישי (אופציונלי) הוא רשימה מופרדת בפסיקים של מחרוזות, כאשר כל מחרוזת היא כתובת IP או טווח CIDR, שיוחרגו מההערכה. רשימת ההחרגות שימושית אם קבוצת כתובות מכילה כתובת IP מסוימת שגורמת לתוצאה חיובית שקרית. הערה: כשמשתמשים ב-`origin.user_ip`, צריך להגדיר את האפשרות `userIpRequestHeaders[]` בשדה `advancedOptionsConfig` של מדיניות האבטחה.
`evaluateAdaptiveProtection(string)`	הפונקציה מחזירה את הערך True אם הבקשה תואמת לחתימת המתקפה שנוצרה על ידי ההגנה האדפטיבית. הארגומנט הוא המזהה של התראה ספציפית שנוצרה על ידי הגנה דינמית אחרי זיהוי של מתקפה.
`evaluateAdaptiveProtectionAutoDeploy()`	הפונקציה מחזירה את הערך True אם הבקשה מגיעה מכתובת IP של תוקף משמעותי שתואמת לחתימת התקפה של התקפה מתמשכת שזוהתה על ידי Adaptive Protection.

דוגמאות

הביטוי הבא משווה את הבקשה הנכנסת לפיד של Google Threat Intelligence‏ iplist-known-malicious-ips כדי להגן מפני רשימה מוכרת של כתובות IP זדוניות:
```
evaluateThreatIntelligence('iplist-known-malicious-ips')
```
הביטוי הבא מתאים לבקשה הנכנסת מול פיד Google Threat Intelligence‏ iplist-known-malicious-ips להגנה מפני רשימת כתובות ה-IP הזדוניות הידועות, למעט כתובות ה-IP ב-104.135.0.0/16:
```
evaluateThreatIntelligence('iplist-known-malicious-ips', ['104.135.0.0/16'])
```
הביטוי הבא מתאים לכותרת הבקשה המותאמת אישית של כתובת ה-IP של המשתמש לקבוצת הכתובות שנקראת my-own-list-of-bad-ips:
```
evaluateAddressGroup('my-own-list-of-bad-ips', origin.user_ip)
```