‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

איסוף יומנים של Tenable Vulnerability Management

נתמך ב:

Google SecOps SIEM

במסמך הזה מוסבר איך להטמיע יומנים של Tenable Vulnerability Management (לשעבר Tenable.io) ב-Google Security Operations. המאמר מתאר שתי שיטות להוספת נתונים: צינור Cloud Storage ששולף נתונים מ-Tenable export API, ו-Tenable Data Stream שדוחף נתונים לקטגוריה של Amazon S3. בוחרים את השיטה שמתאימה לסביבה שלכם.

‫Tenable Vulnerability Management (לשעבר Tenable.io) היא פלטפורמה לניהול נקודות חולשה מבוססת-ענן שמופעלת על ידי טכנולוגיית Nessus. הפלטפורמה מספקת כיסוי מקיף של נקודות חולשה, עם יכולת לחזות אילו בעיות אבטחה צריך לתקן קודם.

הכלי לניתוח מחלץ ממצאים של פגיעויות ונכסים מיומני JSON של Tenable וממפה את השדות ל-UDM. הוא מטפל באינדיקטורים של דומיין, IPv4 ו-IPv6, בחומרה ובמאפייני הנכסים.

לפני שמתחילים

חשוב לוודא שמתקיימות הדרישות המוקדמות הבאות:

מופע של Google SecOps
גישה עם הרשאות למסוף Tenable Vulnerability Management (תפקיד האדמין)
בשיטה 1 (Google Cloud Storage): Google Cloud פרויקט שמופעל בו חיוב והרשאות ליצירת קטגוריות של Cloud Storage, חשבונות שירות, נושאים ב-Pub/Sub, פונקציות של Cloud Run ועבודות של Cloud Scheduler
לשיטה 2 (Amazon S3): חשבון AWS עם הרשאות ליצירת קטגוריות S3, תפקידים ומשתמשים בניהול זהויות והרשאות גישה (IAM)

בוחרים אחת מהשיטות הבאות:

שיטה 1: Google Cloud Storage. פונקציית Cloud Run שולפת נתונים של פגיעויות ונכסים מ-Tenable export API וכותבת אותם לקטגוריה של Cloud Storage. כדאי להשתמש בשיטה הזו כדי להשאיר את צינור הנתונים ב- Google Cloud.
שיטה 2: Amazon S3. ‫Tenable Data Stream דוחף את נתוני Tenable שלכם באופן רציף לקטגוריית Amazon S3. כדאי להשתמש בשיטה הזו אם אתם מעדיפים את השילוב המובנה של Tenable push. ‫Tenable Data Stream תומך רק ב-Amazon S3.

שיטה 1: Google Cloud Storage

בשיטה הזו נעשה שימוש בפונקציה של Cloud Run, שמופעלת על ידי Cloud Scheduler דרך Pub/Sub, כדי לשלוף נתונים של פגיעויות ונכסים מ-Tenable Vulnerability Management export API ולכתוב אותם לקטגוריה של Cloud Storage. לאחר מכן, Google SecOps מעכל את הנתונים מהקטגוריה.

איסוף פרטי הכניסה ל-Tenable Vulnerability Management API

נכנסים אל Tenable Vulnerability Management בכתובת https://cloud.tenable.com.
בפינה השמאלית העליונה, לוחצים על סמל פרופיל המשתמש ובוחרים באפשרות החשבון שלי.
לוחצים על API Keys (מפתחות API).
לוחצים על יצירה.
מעתיקים ושומרים את מפתח הגישה ואת המפתח הסודי.

הערה: המפתחות מוצגים רק פעם אחת. יצירת מפתחות חדשים מבטלת את התוקף של המפתחות הקיימים. משתמשים בשילוב ייעודי עם התפקיד Basic לפחות.

יצירת קטגוריה של Google Cloud Storage

במסוף Google Cloud, עוברים אל Cloud Storage > Buckets.
לוחצים על יצירה.
מספקים את פרטי ההגדרה הבאים:
- שם: מזינים שם ייחודי גלובלית (לדוגמה, tenable-vulnerability-logs).
- סוג המיקום: בוחרים מיקום.
- Storage class: בוחרים באפשרות Standard.
לוחצים על יצירה.

יצירת חשבון שירות לפונקציית Cloud Run

במסוף Google Cloud, עוברים אל IAM & Admin > Service Accounts.
לוחצים על יצירת חשבון שירות.
מספקים את פרטי ההגדרה הבאים:
- שם חשבון השירות: מזינים tenable-collector-sa.
- תיאור חשבון השירות: מזינים Service account for the Tenable export collector.
לוחצים על יצירה והמשך.
לוחצים על סיום.

מעניקים לחשבון השירות גישה לדלי

עוברים אל Cloud Storage > Buckets (קטגוריות).
לוחצים על שם הקטגוריה (לדוגמה, tenable-vulnerability-logs).
עוברים לכרטיסייה Permissions.
לוחצים על הענקת גישה.
מספקים את פרטי ההגדרה הבאים:
- Add principals (הוספת ישויות מורשות): מזינים את כתובת האימייל בחשבון השירות (לדוגמה, tenable-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
- הקצאת תפקידים: בוחרים באפשרות אדמין של אובייקטים באחסון.
לוחצים על Save.

יוצרים נושא Pub/Sub

במסוף Google Cloud, עוברים אל Pub/Sub > Topics.
לוחצים על יצירת נושא.
מזינים מזהה נושא (לדוגמה, tenable-collector-trigger).
לוחצים על יצירה.

יצירת פונקציית Cloud Run לאיסוף יומנים

הפונקציה של Cloud Run מופעלת על ידי הודעות Pub/Sub מ-Cloud Scheduler. הסקריפט מבצע אימות ל-Tenable export API באמצעות מפתחות ה-API שלכם, מריץ את הייצוא של הפגיעויות והנכסים וכותב כל נתח ייצוא לקטגוריה בפורמט JSON.

במסוף Google Cloud, עוברים אל Cloud Run.
לוחצים על יצירת שירות.
בוחרים באפשרות Function כדי להשתמש בעורך הקוד המוטבע.
מספקים את פרטי ההגדרה הבאים:
- שם השירות: מזינים tenable-collector.
- אזור: בוחרים את האזור שמתאים לדלי (לדוגמה, us-central1).
- זמן ריצה: בוחרים באפשרות Python 3.12 ואילך.
בקטע Trigger (טריגר):
1. לוחצים על הוספת טריגר.
2. בוחרים באפשרות Cloud Pub/Sub.
3. בקטע Select a Cloud Pub/Sub topic, בוחרים באפשרות tenable-collector-trigger.
4. לוחצים על Save.
בקטע Authentication, בוחרים באפשרות Require authentication.
מרחיבים את Containers, Networking, Security, ובכרטיסייה Security מגדירים את חשבון שירות ל-tenable-collector-sa.

בכרטיסייה Containers > Variables & Secrets (קונטיינרים > משתנים וסודות), מוסיפים את משתני הסביבה הבאים:

שם המשתנה	ערך לדוגמה
`TIO_ACCESS_KEY`	`your-tenable-access-key`
`TIO_SECRET_KEY`	`your-tenable-secret-key`
`GCS_BUCKET`	`tenable-vulnerability-logs`
`GCS_PREFIX`	`tenable/`
`NUM_ASSETS`	`1000`
`ASSET_CHUNK_SIZE`	`1000`
`SEVERITIES`	`low,medium,high,critical`
`HTTP_TIMEOUT`	`120`

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

הוספת קוד הפונקציה

בשדה Function entry point (נקודת כניסה לפונקציה), מזינים main.
בעורך הקוד המוטבע, מחליפים את התוכן של requirements.txt בתוכן הבא:
```
functions-framework==3.*
google-cloud-storage==2.*
requests==2.*
```

מחליפים את התוכן של main.py בקוד הבא:

import json
import os
import time

import functions_framework
import requests
from google.cloud import storage

BASE = "https://cloud.tenable.com"
ACCESS_KEY = os.environ["TIO_ACCESS_KEY"]
SECRET_KEY = os.environ["TIO_SECRET_KEY"]
GCS_BUCKET = os.environ["GCS_BUCKET"]
GCS_PREFIX = os.environ.get("GCS_PREFIX", "tenable/")
NUM_ASSETS = int(os.environ.get("NUM_ASSETS", "1000"))
ASSET_CHUNK_SIZE = int(os.environ.get("ASSET_CHUNK_SIZE", "1000"))
SEVERITIES = [s for s in os.environ.get("SEVERITIES", "low,medium,high,critical").split(",") if s]
HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "120"))

HEADERS = {
    "X-ApiKeys": f"accessKey={ACCESS_KEY};secretKey={SECRET_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
}

storage_client = storage.Client()

def _request(method, path, **kwargs):
    """Call the Tenable API, honoring HTTP 429 Retry-After. Do not multi-thread."""
    while True:
        resp = requests.request(method, f"{BASE}{path}", headers=HEADERS, timeout=HTTP_TIMEOUT, **kwargs)
        if resp.status_code == 429:
            time.sleep(int(resp.headers.get("Retry-After", "30")))
            continue
        resp.raise_for_status()
        return resp

def _write_chunk(bucket, name, payload):
    """Write one export chunk (a JSON array) to the bucket."""
    blob = bucket.blob(f"{GCS_PREFIX}{name}")
    blob.upload_from_string(json.dumps(payload), content_type="application/json")

def _run_export(bucket, label, request_path, status_kind, body):
    """Request an export, poll until FINISHED, and write each chunk to the bucket."""
    export_uuid = _request("POST", request_path, json=body).json()["export_uuid"]
    written = set()
    while True:
        status = _request("GET", f"/{status_kind}/export/{export_uuid}/status").json()
        for chunk_id in status.get("chunks_available", []):
            if chunk_id in written:
                continue
            chunk = _request("GET", f"/{status_kind}/export/{export_uuid}/chunks/{chunk_id}").json()
            _write_chunk(bucket, f"{label}_{export_uuid}_{chunk_id}.json", chunk)
            written.add(chunk_id)
        state = status.get("status")
        if state == "FINISHED":
            break
        if state in ("ERROR", "CANCELLED"):
            raise RuntimeError(f"{label} export {export_uuid} ended as {state}")
        time.sleep(15)
    print(f"{label}: wrote {len(written)} chunk(s) for export {export_uuid}")

@functions_framework.cloud_event
def main(cloud_event):
    bucket = storage_client.bucket(GCS_BUCKET)
    # Vulnerabilities: request path and status/chunk paths both use /vulns/export; body uses num_assets.
    _run_export(
        bucket, "vulns", "/vulns/export", "vulns",
        {"num_assets": NUM_ASSETS, "include_unlicensed": False, "filters": {"severity": SEVERITIES}},
    )
    # Assets: request path is /assets/v2/export (body uses chunk_size); status/chunk paths drop the v2.
    _run_export(
        bucket, "assets", "/assets/v2/export", "assets",
        {"chunk_size": ASSET_CHUNK_SIZE},
    )
    return "ok"

לוחצים על שמירה ופריסה.

יצירת משימה ב-Cloud Scheduler

במסוף Google Cloud, עוברים אל Cloud Scheduler.
לוחצים על Create job (יצירת עבודה).
מספקים את פרטי ההגדרה הבאים:
- שם: מזינים tenable-collector-schedule.
- אזור: בוחרים את אותו אזור כמו פונקציית Cloud Run.
- תדירות: מזינים לוח זמנים של cron (לדוגמה, 0 */6 * * * להפעלה כל שש שעות).
- אזור זמן: בוחרים את אזור הזמן.
בשדה Target type, בוחרים באפשרות Pub/Sub.
בוחרים את הנושא tenable-collector-trigger.
בגוף ההודעה, כותבים run.
לוחצים על יצירה.

הגדרת פיד ב-Google SecOps להעברה מ-Google Cloud Storage

עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
לוחצים על הוספת פיד חדש.
לוחצים על Configure a single feed (הגדרת פיד יחיד).
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Tenable Vulnerability Management GCS).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות tenable.io בתור סוג היומן.
לוחצים על קבלת חשבון שירות. מעתיקים את כתובת האימייל בחשבון השירות שמוצגת.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- URI של קטגוריית אחסון: מזינים את ה-URI של הקטגוריה, כולל הקידומת (לדוגמה, gs://tenable-vulnerability-logs/tenable/).
- אפשרות למחיקת מקור: בוחרים את אפשרות המחיקה הרצויה.
- הגיל המקסימלי של הקובץ: כולל קבצים שעברו שינוי במספר הימים האחרון. ברירת המחדל היא 180 ימים.
לוחצים על הבא, בודקים את ההגדרות ולוחצים על שליחה.

נותנים לחשבון השירות של Google SecOps גישה לקטגוריה

עוברים אל Cloud Storage > Buckets ולוחצים על שם הקטגוריה.
עוברים לכרטיסייה Permissions ולוחצים על Grant access.
בתיבת הדו-שיח Add principals, מזינים את כתובת האימייל בחשבון השירות שהעתקתם מהפיד.
מקצים את התפקיד Storage Object Viewer (או Storage Object Admin אם בחרתם באפשרות למחיקת המקור).
לוחצים על Save.

שיטה 2: Amazon S3

בשיטה הזו משתמשים ב-Tenable Data Stream כדי להעביר את נתוני Tenable באופן רציף לקטגוריה של Amazon S3 בפורמט JSON. לאחר מכן, Google SecOps מעכל את הנתונים מהקטגוריה. Tenable Data Stream תומך רק ב-Amazon S3, והאימות לחשבון AWS מתבצע באמצעות תפקיד IAM ש-Tenable מקבל (יחסי אמון בין חשבונות עם מזהה חיצוני).

יצירת קטגוריה ב-Amazon S3

יוצרים קטגוריה ב-Amazon S3 לפי המדריך של AWS בנושא יצירת קטגוריה.
שומרים את השם של ה-bucket ואת האזור לעיון בהמשך (לדוגמה, tenable-vm-logs).

יצירת תפקיד IAM עבור Tenable Data Stream

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

ב-Tenable Vulnerability Management, עוברים אל Settings > Tenable Data Stream ולוחצים על Add an Integration (הוספת שילוב). חשוב להשאיר את תיבת הדו-שיח הזו פתוחה כדי להעתיק את מדיניות ההרשאות ואת המזהה החיצוני בשלב מאוחר יותר.
במסוף AWS, עוברים אל IAM > Roles > Create role (תפקידים > יצירת תפקיד).

בוחרים באפשרות Custom trust policy ומדביקים את מדיניות האמון מהחלונית IAM Role Guidelines של Tenable (לוחצים על Copy Trust Policy). מדיניות ההרשאות נראית כך:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": { "AWS": "arn:aws:iam::<TENABLE_AWS_ACCOUNT_ID>:root" },
            "Action": "sts:AssumeRole",
            "Condition": { "StringEquals": { "sts:ExternalId": "<TENABLE_EXTERNAL_ID>" } }
        }
    ]
}

לוחצים על Next (הבא), ואז יוצרים ומצרפים מדיניות שמעניקה ל-Tenable הרשאת כתיבה לקטגוריה (מחליפים את tenable-vm-logs בשם הקטגוריה):

‫

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": ["s3:PutObject", "s3:GetBucketLocation", "s3:ListBucket"],
            "Resource": [
                "arn:aws:s3:::tenable-vm-logs",
                "arn:aws:s3:::tenable-vm-logs/*"
            ]
        }
    ]
}

מזינים שם תפקיד (לדוגמה, TenableDataStreamRole) ולוחצים על יצירת תפקיד. שומרים את שם התפקיד ואת מזהה החשבון ב-AWS.

הגדרת מקור נתונים של Tenable

חוזרים לתיבת הדו-שיח Add an Integration ב-Tenable Vulnerability Management (Settings > Tenable Data Stream).
מספקים את פרטי ההגדרה הבאים:
- שם השילוב: מזינים שם תיאורי (לדוגמה, Google SecOps Integration).
- סוג השילוב: בוחרים באפשרות AWS S3 (האפשרות היחידה שזמינה).
- נתוני שילוב: בוחרים את סוגי הנתונים להזרמה (לדוגמה, נכסים, נקודות חולשה וביקורת על מארח).
- התראה באימייל (אופציונלי): מזינים כתובת אימייל כדי לקבל התראה אם הסטטוס של הזרם משתנה.
לוחצים על הבא ומזינים את פרטי תפקיד ה-IAM:
- מזהה חשבון AWS: מזינים את מזהה החשבון ב-AWS.
- שם תפקיד IAM: מזינים את התפקיד שיצרתם (לדוגמה, TenableDataStreamRole).
- מזהה חיצוני: משתמשים במזהה החיצוני שמוצג על ידי Tenable בתיבת הדו-שיח הזו (אותו ערך שמופיע במדיניות האמון).
לוחצים על הבא ומזינים את פרטי הקטגוריה:
- שם קטגוריית S3: מזינים את שם הקטגוריה (לדוגמה, tenable-vm-logs).
- קידומת נתיב: מזינים קידומת לארגון הקבצים (לדוגמה, tenable/).
לוחצים על Save. מערכת Tenable כותבת נתוני JSON לדלי שלכם באופן רציף.

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

יצירת משתמש IAM כדי ש-Google SecOps יוכל לקרוא את ה-bucket

‫Google SecOps קורא את ה-bucket באמצעות משתמש IAM נפרד עם הרשאת קריאה בלבד (הזהות הזו לא תלויה בתפקיד שבו Tenable משתמשת כדי לכתוב).

במסוף AWS, עוברים אל IAM > Users > Create user.
מזינים שם משתמש (לדוגמה, secops-tenable-reader) ולוחצים על הבא.
לוחצים על הבא ואז על יצירת משתמש.
בוחרים את המשתמש, עוברים לכרטיסייה Permissions (הרשאות) ולוחצים על Add permissions > Create inline policy > JSON (הוספת הרשאות > יצירת מדיניות מוטמעת > JSON). מדביקים את המדיניות הבאה של קריאה בלבד (מחליפים את tenable-vm-logs בשם הקטגוריה):
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": ["s3:GetObject", "s3:ListBucket", "s3:GetBucketLocation"],
            "Resource": [
                "arn:aws:s3:::tenable-vm-logs",
                "arn:aws:s3:::tenable-vm-logs/*"
            ]
        }
    ]
}
```
הערה: אם בוחרים באפשרות למחיקת מקור בפיד, צריך גם להעניק את ההרשאה s3:DeleteObject ב-arn:aws:s3:::tenable-vm-logs/*.
עוברים לכרטיסייה Security credentials (פרטי כניסה לאבטחה) ולוחצים על Create access key (יצירת מפתח גישה).
בוחרים באפשרות שירות צד שלישי בתור תרחיש השימוש, לוחצים על הבא ואז על יצירת מפתח גישה.
מעתיקים ושומרים את מפתח הגישה ואת מפתח הגישה הסודי.

הגדרת פיד ב-Google SecOps לצורך קליטה מ-Amazon S3

עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
לוחצים על הוספת פיד חדש.
לוחצים על Configure a single feed (הגדרת פיד יחיד).
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Tenable Vulnerability Management S3).
בוחרים באפשרות Amazon S3 V2 בתור סוג המקור.
בוחרים באפשרות tenable.io בתור סוג היומן.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- S3 URI: מזינים את ה-URI של הקטגוריה, כולל הקידומת (לדוגמה, s3://tenable-vm-logs/tenable/).
- אפשרות למחיקת מקור: בוחרים את אפשרות המחיקה הרצויה.
- הגיל המקסימלי של הקובץ: כולל קבצים שעברו שינוי במספר הימים האחרון. ברירת המחדל היא 180 ימים.
- ‫Access Key ID (מזהה מפתח גישה): מזינים את מפתח הגישה של משתמש IAM עם הרשאת קריאה בלבד.
- מפתח גישה סודי: מזינים את המפתח הסודי של משתמש IAM עם הרשאת קריאה בלבד.
לוחצים על הבא, בודקים את ההגדרות ולוחצים על שליחה.

טבלת מיפוי UDM

שדה ביומן	מיפוי UDM	היגיון
`payload.path`	`about.file.full_path`	מיפוי ישיר
`payload.md5`	`about.file.md5`	מיפוי ישיר
`asset.uuid`	`entity.asset.asset_id`	מיפוי ישיר
`id`	`entity.asset.asset_id`	מיפוי ישיר
`payload_id`	`entity.asset.asset_id`	מיפוי ישיר
`ssh_fingerprints.0`	`entity.asset.attribute.labels.value`	מיפוי ישיר
`system_types.0`	`entity.asset.attribute.labels.value`	מיפוי ישיר
`asset.hostname`	`entity.asset.hostname`	מיפוי ישיר
`asset.last_scan_target`	`entity.asset.hostname`	מיפוי ישיר
`host`	`entity.asset.hostname`	מיפוי ישיר
`scan.target`	`entity.asset.hostname`	מיפוי ישיר
`asset.ipv4`	`entity.asset.ip`	ממוזג
`ip`	`entity.asset.ip`	ממוזג
`ipaddr`	`entity.asset.ip`	ממוזג
`prinIP`	`entity.asset.ip`	ממוזג
`scan_ipaddr`	`entity.asset.ip`	ממוזג
`updateIndex`	`entity.asset.ip`	מיפוי: `0` → `update_ipv4_0`
`update_ipv4_0`	`entity.asset.ip`	ממוזג
`asset.mac_address`	`entity.asset.mac`	ממוזג
`mac`	`entity.asset.mac`	ממוזג
`fqdns.0`	`entity.asset.network_domain`	מיפוי ישיר
`netbios_names.0`	`entity.asset.network_domain`	מיפוי ישיר
`os_family`	`entity.asset.platform_software.platform`	מיפוי ישיר
`asset.operating_system.0`	`entity.asset.platform_software.platform_version`	מיפוי ישיר
`asset.uuid`	`entity.asset.product_object_id`	מיפוי ישיר
`id`	`entity.asset.product_object_id`	מיפוי ישיר
`payload_id`	`entity.asset.product_object_id`	מיפוי ישיר
`vuln.vulnerabilities`	`entity.asset.vulnerabilities`	ממוזג
`vuln1.vulnerabilities`	`entity.asset.vulnerabilities`	ממוזג
`vuln2.vulnerabilities`	`entity.asset.vulnerabilities`	ממוזג
`asset.device_type`	`metadata.description`	מיפוי ישיר
`plugin.description`	`metadata.description`	מיפוי ישיר
`has_entity_asset`	`metadata.entity_type`	מיפוי: `true` → `ASSET`
`first_found`	`metadata.event_timestamp`	ניתוח הכתובות שברשימה: `ISO8601`
`last_found`	`metadata.event_timestamp`	ניתוח הכתובות שברשימה: `ISO8601`
`scan.completed_at`	`metadata.event_timestamp`	ניתוח הכתובות שברשימה: `ISO8601`
`scan.started_at`	`metadata.event_timestamp`	ניתוח הכתובות שברשימה: `ISO8601`
`has_entity_asset`	`metadata.product_name`	מיפוי: `true` → `Tenable IO`
`has_entity_asset`	`metadata.vendor_name`	מיפוי: `true` → `Tenable IO`
`port.protocol`	`network.ip_protocol`	מיפוי ישיר
`asset.network_id`	`network.session_id`	מיפוי ישיר
`sec_res.description`	`security_result.description`	מיפוי ישיר
`asset_agent_uuid_label`	`security_result.detection_fields`	ממוזג
`asset_bios_uuid_label`	`security_result.detection_fields`	ממוזג
`asset_netbios_name_label`	`security_result.detection_fields`	ממוזג
`finding_id_label`	`security_result.detection_fields`	ממוזג
`plugin_family_id_label`	`security_result.detection_fields`	ממוזג
`plugin_family_label`	`security_result.detection_fields`	ממוזג
`plugin_risk_factor_label`	`security_result.detection_fields`	ממוזג
`plugin_xrefs_label`	`security_result.detection_fields`	ממוזג
`risk_factor_label`	`security_result.detection_fields`	ממוזג
`scan_label`	`security_result.detection_fields`	ממוזג
`scan_schedule_uuid_label`	`security_result.detection_fields`	ממוזג
`scan_started_at_label`	`security_result.detection_fields`	ממוזג
`scan_uuid_label`	`security_result.detection_fields`	ממוזג
`see_also_label`	`security_result.detection_fields`	ממוזג
`severity_default_id_label`	`security_result.detection_fields`	ממוזג
`severity_id_label`	`security_result.detection_fields`	ממוזג
`severity_label`	`security_result.detection_fields`	ממוזג
`severity_modification_type_label`	`security_result.detection_fields`	ממוזג
`update_finding_id_label`	`security_result.detection_fields`	ממוזג
`update_first_scan_time_label`	`security_result.detection_fields`	ממוזג
`update_last_licensed_scan_date_label`	`security_result.detection_fields`	ממוזג
`update_last_scan_id_label`	`security_result.detection_fields`	ממוזג
`update_last_scan_time_label`	`security_result.detection_fields`	ממוזג
`update_last_schedule_id_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss3_vector_access_complexity_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss3_vector_access_vector_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss3_vector_authentication_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss3_vector_availability_impact_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss3_vector_confidentiality_impact_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss3_vector_integrity_impact_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss3_vector_privileges_required_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss3_vector_raw_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss3_vector_user_interaction_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss_base_score_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss_vector_access_complexity_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss_vector_access_vector_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss_vector_authentication_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss_vector_availability_impact_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss_vector_confidentiality_impact_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss_vector_integrity_impact_label`	`security_result.detection_fields`	ממוזג
`update_plugin_cvss_vector_raw_label`	`security_result.detection_fields`	ממוזג
`update_plugin_see_also_label`	`security_result.detection_fields`	ממוזג
`update_plugin_stig_severity_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_driver_cvss3_impact_score_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_drivers_age_of_vuln_lower_bound_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_drivers_age_of_vuln_upper_bound_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_drivers_cvss_impact_score_predicted_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_drivers_exploit_code_maturity_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_drivers_product_coverage_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_drivers_threat_intensity_last28_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_drivers_threat_recency_lower_bound_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_drivers_threat_recency_upper_bound_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_score_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_updated_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_v2_cve_id_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_v2_exploit_code_maturity_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_v2_in_the_news_intensity_last30_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_v2_in_the_news_recency_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_v2_malware_observations_intensity_last30_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_v2_malware_observations_recency_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vpr_v2_on_cisa_kev_label`	`security_result.detection_fields`	ממוזג
`update_plugin_vuln_publication_date_label`	`security_result.detection_fields`	ממוזג
`update_plugin_xrefs_id_type_label`	`security_result.detection_fields`	ממוזג
`update_plugin_xrefs_type_label`	`security_result.detection_fields`	ממוזג
`update_scan_started_at_label`	`security_result.detection_fields`	ממוזג
`update_severity_default_id_label`	`security_result.detection_fields`	ממוזג
`update_severity_id_label`	`security_result.detection_fields`	ממוזג
`update_severity_modification_type_label`	`security_result.detection_fields`	ממוזג
`updates_asset_netbios_name_label`	`security_result.detection_fields`	ממוזג
`updates_plugin_vpr_v2_exploit_probability_label`	`security_result.detection_fields`	ממוזג
`updates_plugin_vpr_v2_label`	`security_result.detection_fields`	ממוזג
`updates_plugin_vpr_v2_percentile_label`	`security_result.detection_fields`	ממוזג
`updates_plugin_vpr_v2_vpr_severity_label`	`security_result.detection_fields`	ממוזג
`version_label`	`security_result.detection_fields`	ממוזג
`xref_label`	`security_result.detection_fields`	ממוזג
`severity`	`security_result.severity`	מיפוי ישיר
לא רלוונטי	`entity.asset.attribute.labels.key`	קבוע: `ssh_fingerprints`
לא רלוונטי	`metadata.entity_type`	קבוע: `ASSET`
לא רלוונטי	`metadata.product_name`	קבוע: `Tenable IO`
לא רלוונטי	`metadata.vendor_name`	קבוע: `Tenable IO`
לא רלוונטי	`security_result.severity`	קבוע: `CRITICAL`

יומן שינויים

צפייה ביומן השינויים של מנתח התוכן הזה

הבעיה עדיין לא נפתרה? קבלת תשובות מחברי הקהילה וממומחי Google SecOps.