איסוף יומנים של Censys ASM

גרסת כלי הניתוח: 1.0

נתמך ב:

במאמר הזה מוסבר איך להטמיע יומנים של Censys ב-Google Security Operations באמצעות Google Cloud Storage V2.

‫Censys מספקת ניהול מקיף של שטח ההתקפה ומודיעין אינטרנטי באמצעות ה-API שלה. השילוב הזה מאפשר לכם לאסוף אירועים של גילוי מארחים, אירועי סיכון ושינויים בנכסים מ-Censys ASM ולהעביר אותם ל-Google SecOps לצורך ניתוח ומעקב.

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

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

  • מופע של Google SecOps
  • פרויקט ב-GCP עם Cloud Storage API מופעל
  • הרשאות ליצירה ולניהול של מאגרי GCS
  • הרשאות לניהול מדיניות IAM בקטגוריות GCS
  • הרשאות ליצירת שירותי Cloud Run, נושאי Pub/Sub ומשימות Cloud Scheduler
  • גישה עם הרשאות מיוחדות ל-Censys ASM

איסוף פרטי הכניסה ל-Censys API

  1. נכנסים ל-Censys ASM Console בכתובת app.censys.io.
  2. עוברים אל שילובים בחלק העליון של הדף.
  3. מעתיקים את מפתח ה-API ואת מזהה הארגון ושומרים אותם.
  4. שימו לב לכתובת הבסיס של ה-API: https://api.platform.censys.io

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

  1. נכנסים אל מסוף Google Cloud.
  2. בוחרים פרויקט או יוצרים פרויקט חדש.
  3. בתפריט הניווט, עוברים אל Cloud Storage > Buckets.
  4. לוחצים על Create bucket.

  5. מספקים את פרטי ההגדרה הבאים:

    הגדרה ערך
    Name your bucket (שם הקטגוריה) מזינים שם ייחודי גלובלית (לדוגמה, censys-logs)
    סוג המיקום בוחרים לפי הצרכים (אזור, שני אזורים, מספר אזורים)
    Location בוחרים את המיקום (לדוגמה, us-central1).
    סוג אחסון (storage class) רגיל (מומלץ ליומנים שמתבצעת אליהם גישה לעיתים קרובות)
    בקרת גישה אחיד (מומלץ)
    כלים להגנה אופציונלי: הפעלת ניהול גרסאות של אובייקטים או מדיניות שמירת נתונים

  6. לוחצים על יצירה.

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

פונקציית Cloud Run צריכה חשבון שירות עם הרשאות כתיבה לקטגוריה של GCS.

יצירת חשבון שירות

  1. במסוף GCP, עוברים אל IAM & Admin > Service Accounts.
  2. לוחצים על יצירת חשבון שירות.
  3. מספקים את פרטי ההגדרה הבאים:
    • שם חשבון השירות: מזינים censys-data-collector-sa.
    • תיאור חשבון השירות: מזינים Service account for Cloud Run function to collect Censys logs.
  4. לוחצים על יצירה והמשך.
  5. בקטע Grant this service account access to project (מתן גישה של חשבון השירות הזה לפרויקט), מוסיפים את התפקידים הבאים:
    1. לוחצים על בחירת תפקיד.
    2. מחפשים את Storage Object Admin ולוחצים עליו.
    3. לוחצים על + הוספת תפקיד נוסף.
    4. מחפשים את האפשרות Cloud Run Invoker (הפעלת שירותים ב-Cloud Run) ולוחצים עליה.
    5. לוחצים על + הוספת תפקיד נוסף.
    6. מחפשים את האפשרות Cloud Functions Invoker (הפעלת פונקציות של Cloud Functions) ולוחצים עליה.
  6. לוחצים על Continue.
  7. לוחצים על סיום.

התפקידים האלה נדרשים כדי:

  • אדמין של אובייקט אחסון: כתיבת יומנים לקטגוריית GCS וניהול קבצי מצב
  • ‫Cloud Run Invoker: מתן הרשאה ל-Pub/Sub להפעיל את הפונקציה
  • Cloud Functions Invoker: מאפשר הפעלה של פונקציות

מתן הרשאות IAM בקטגוריית GCS

נותנים לחשבון השירות הרשאות כתיבה בקטגוריית GCS:

  1. עוברים אל Cloud Storage > Buckets (קטגוריות).
  2. לוחצים על שם הקטגוריה.
  3. עוברים לכרטיסייה Permissions.
  4. לוחצים על הענקת גישה.
  5. מספקים את פרטי ההגדרה הבאים:
    • Add principals (הוספת ישויות מורשות): מזינים את כתובת האימייל בחשבון השירות (לדוגמה, censys-data-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • הקצאת תפקידים: בוחרים באפשרות אדמין של אובייקטים באחסון.
  6. לוחצים על Save.

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

יוצרים נושא Pub/Sub ש-Cloud Scheduler יפרסם בו ופונקציית Cloud Run תירשם אליו.

  1. במסוף GCP, עוברים אל Pub/Sub > Topics.
  2. לוחצים על יצירת נושא.
  3. מספקים את פרטי ההגדרה הבאים:
    • מזהה הנושא: מזינים censys-data-trigger.
    • משאירים את שאר ההגדרות כברירת מחדל.
  4. לוחצים על יצירה.

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

הפונקציה Cloud Run מופעלת על ידי הודעות Pub/Sub מ-Cloud Scheduler כדי לאחזר יומנים מ-Censys ASM API ולכתוב אותם ב-GCS.

  1. במסוף GCP, עוברים אל Cloud Run.
  2. לוחצים על יצירת שירות.
  3. בוחרים באפשרות Function (שימוש בעורך ישיר ליצירת פונקציה).

  4. בקטע Configure (הגדרה), מזינים את פרטי ההגדרה הבאים:

    הגדרה ערך
    שם השירות censys-data-collector
    אזור בוחרים אזור שתואם ל-GCS Bucket (לדוגמה, us-central1)
    זמן ריצה בוחרים באפשרות Python 3.12 ואילך.

  5. בקטע טריגר (אופציונלי):

    1. לוחצים על + הוספת טריגר.
    2. בוחרים באפשרות Cloud Pub/Sub.
    3. בקטע Select a Cloud Pub/Sub topic, בוחרים את הנושא ב-Pub/Sub ‏ (censys-data-trigger).
    4. לוחצים על Save.

  6. בקטע Authentication:

    • בוחרים באפשרות דרישת אימות.
    • בודקים את ניהול זהויות והרשאות גישה (IAM).
  1. גוללים למטה ומרחיבים את Containers, Networking, Security (מאגרי תגים, רשתות, אבטחה).
  2. עוברים לכרטיסייה אבטחה:
    • חשבון שירות: בוחרים את חשבון השירות (censys-data-collector-sa).

  3. עוברים לכרטיסייה מאגרי תגים:

    1. לוחצים על Variables & Secrets (משתנים וסודות).

    2. לוחצים על + הוספת משתנה לכל משתנה סביבתי:

      שם המשתנה ערך לדוגמה
      GCS_BUCKET censys-logs
      GCS_PREFIX censys/
      STATE_KEY censys/state.json
      CENSYS_API_KEY your-censys-api-key
      CENSYS_ORG_ID your-organization-id
      API_BASE https://api.platform.censys.io

  4. בכרטיסייה Variables & Secrets, גוללים למטה אל Requests:

    • זמן קצוב לתפוגת בקשה: מזינים 600 שניות (10 דקות).

  5. עוברים לכרטיסייה הגדרות במאגרי תגים:

    • בקטע Resources (מקורות מידע):
      • זיכרון: בוחרים באפשרות ‎512 MiB או יותר.
      • מעבד: בוחרים באפשרות 1.
    • לוחצים על סיום.

  6. גוללים אל סביבת הפעלה:

    • בוחרים באפשרות ברירת מחדל (מומלץ).

  7. בקטע שינוי קנה מידה של העריכה:

    • מספר המינימום של מופעים: מזינים 0.
    • מספר מקסימלי של מופעים: מזינים 100 (או משנים בהתאם לעומס הצפוי).

  8. לוחצים על יצירה.

  9. ממתינים ליצירת השירות (1-2 דקות).

  10. אחרי שיוצרים את השירות, עורך הקוד המוטבע נפתח באופן אוטומטי.

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

  1. מזינים main בFunction entry point

  2. בעורך הקוד המוטבע, יוצרים שני קבצים:

    • הקובץ הראשון: main.py:
    import functions_framework
from google.cloud import storage
import json
import urllib3
import gzip
import os
from datetime import datetime, timedelta, timezone
from typing import Dict, List, Any, Optional
from urllib.parse import urlencode

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=5.0, read=30.0),
    retries=False,
)

# Initialize Storage client
storage_client = storage.Client()

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch logs from Censys ASM API and write to GCS.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """

    # Get environment variables
    bucket_name = os.environ.get('GCS_BUCKET')
    prefix = os.environ.get('GCS_PREFIX', 'censys/')
    state_key = os.environ.get('STATE_KEY', 'censys/state.json')
    censys_api_key = os.environ.get('CENSYS_API_KEY')
    censys_org_id = os.environ.get('CENSYS_ORG_ID')
    api_base = os.environ.get('API_BASE', 'https://api.platform.censys.io')

    if not all([bucket_name, censys_api_key, censys_org_id]):
        print('Error: Missing required environment variables')
        return

    try:
        collector = CensysCollector(
            bucket_name=bucket_name,
            prefix=prefix,
            state_key=state_key,
            api_key=censys_api_key,
            org_id=censys_org_id,
            api_base=api_base
        )

        # Get last collection time
        last_collection_time = collector.get_last_collection_time()
        current_time = datetime.now(timezone.utc)

        print(f'Collecting events since {last_collection_time}')

        # Collect different types of events
        logbook_events = collector.collect_logbook_events()
        risk_events = collector.collect_risks_events()

        # Save events to GCS
        collector.save_events_to_gcs(logbook_events, 'logbook')
        collector.save_events_to_gcs(risk_events, 'risks')

        # Update state
        collector.save_collection_time(current_time)

        print(f'Successfully processed {len(logbook_events)} logbook events and {len(risk_events)} risk events')

    except Exception as e:
        print(f'Error processing logs: {str(e)}')
        raise

class CensysCollector:
    def __init__(self, bucket_name: str, prefix: str, state_key: str, 
                 api_key: str, org_id: str, api_base: str):
        self.bucket_name = bucket_name
        self.prefix = prefix
        self.state_key = state_key
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'X-Organization-ID': org_id,
            'Content-Type': 'application/json'
        }
        self.api_base = api_base
        self.bucket = storage_client.bucket(bucket_name)

    def get_last_collection_time(self) -> Optional[datetime]:
        """Get the last collection timestamp from GCS state file."""
        try:
            blob = self.bucket.blob(self.state_key)
            if blob.exists():
                state_data = blob.download_as_text()
                state = json.loads(state_data)
                return datetime.fromisoformat(state.get('last_collection_time', '2024-01-01T00:00:00Z'))
        except Exception as e:
            print(f'No state file found or error reading state: {e}')
        return datetime.now(timezone.utc) - timedelta(hours=1)

    def save_collection_time(self, collection_time: datetime):
        """Save the current collection timestamp to GCS state file."""
        state = {'last_collection_time': collection_time.strftime('%Y-%m-%dT%H:%M:%SZ')}
        blob = self.bucket.blob(self.state_key)
        blob.upload_from_string(
            json.dumps(state),
            content_type='application/json'
        )

    def collect_logbook_events(self, cursor: str = None) -> List[Dict[str, Any]]:
        """Collect logbook events from Censys ASM API using cursor-based pagination."""
        events = []
        url = f"{self.api_base}/v3/logbook"

        params = {}
        if cursor:
            params['cursor'] = cursor

        try:
            query_string = urlencode(params) if params else ''
            full_url = f"{url}?{query_string}" if query_string else url

            response = http.request('GET', full_url, headers=self.headers)

            # Handle rate limiting with exponential backoff
            if response.status == 429:
                retry_after = int(response.headers.get('Retry-After', '60'))
                print(f'Rate limited (429). Retrying after {retry_after}s...')
                import time
                time.sleep(retry_after)
                return self.collect_logbook_events(cursor)

            if response.status != 200:
                print(f'API request failed with status {response.status}: {response.data}')
                return []

            data = json.loads(response.data.decode('utf-8'))
            events.extend(data.get('logbook_entries', []))

            # Handle cursor-based pagination
            next_cursor = data.get('next_cursor')
            if next_cursor:
                events.extend(self.collect_logbook_events(next_cursor))

            print(f'Collected {len(events)} logbook events')
            return events

        except Exception as e:
            print(f'Error collecting logbook events: {e}')
            return []

    def collect_risks_events(self) -> List[Dict[str, Any]]:
        """Collect risk events from Censys ASM API."""
        events = []
        url = f"{self.api_base}/v3/risks"

        try:
            response = http.request('GET', url, headers=self.headers)

            # Handle rate limiting with exponential backoff
            if response.status == 429:
                retry_after = int(response.headers.get('Retry-After', '60'))
                print(f'Rate limited (429). Retrying after {retry_after}s...')
                import time
                time.sleep(retry_after)
                return self.collect_risks_events()

            if response.status != 200:
                print(f'API request failed with status {response.status}: {response.data}')
                return []

            data = json.loads(response.data.decode('utf-8'))
            events.extend(data.get('risks', []))

            print(f'Collected {len(events)} risk events')
            return events

        except Exception as e:
            print(f'Error collecting risk events: {e}')
            return []

    def save_events_to_gcs(self, events: List[Dict[str, Any]], event_type: str):
        """Save events to GCS in compressed NDJSON format."""
        if not events:
            return

        timestamp = datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
        filename = f"{self.prefix}{event_type}_{timestamp}.json.gz"

        try:
            # Convert events to newline-delimited JSON
            ndjson_content = '\n'.join(json.dumps(event, separators=(',', ':')) for event in events)

            # Compress with gzip
            gz_bytes = gzip.compress(ndjson_content.encode('utf-8'))

            blob = self.bucket.blob(filename)
            blob.upload_from_string(
                gz_bytes,
                content_type='application/gzip'
            )

            print(f'Saved {len(events)} {event_type} events to {filename}')

        except Exception as e:
            print(f'Error saving {event_type} events to GCS: {e}')
            raise
    • הקובץ השני: requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

  3. לוחצים על Deploy כדי לשמור ולפרוס את הפונקציה.

  4. ממתינים לסיום הפריסה (2-3 דקות).

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

‫Cloud Scheduler מפרסם הודעות בנושא Pub/Sub במרווחי זמן קבועים, וכך מפעיל את הפונקציה של Cloud Run.

  1. במסוף GCP, עוברים אל Cloud Scheduler.
  2. לוחצים על Create Job (יצירת משימה).

  3. מספקים את פרטי ההגדרה הבאים:

    הגדרה ערך
    שם censys-data-collector-hourly
    אזור בחירה באותו אזור כמו פונקציית Cloud Run
    תדירות ‫0 * * * * (כל שעה, בדיוק בשעה)
    אזור זמן בחירת אזור זמן (מומלץ לבחור UTC)
    סוג הטירגוט Pub/Sub
    נושא בוחרים את נושא Pub/Sub (censys-data-trigger).
    גוף ההודעה ‫{} (אובייקט JSON ריק)

  4. לוחצים על יצירה.

אפשרויות לתדירות התזמון

  • בחירת התדירות בהתאם לנפח היומן ולדרישות זמן האחזור:

    תדירות ביטוי Cron תרחיש לדוגמה
    כל 5 דקות */5 * * * * נפח גבוה, זמן אחזור נמוך
    כל 15 דקות */15 * * * * נפח חיפושים בינוני
    כל שעה 0 * * * * רגיל (מומלץ)
    כל 6 שעות 0 */6 * * * נפח נמוך, עיבוד באצווה
    יומי 0 0 * * * איסוף נתונים היסטוריים

בדיקת השילוב

  1. במסוף Cloud Scheduler, מוצאים את העבודה.
  2. לוחצים על הפעלת המשימה בכוח כדי להפעיל את המשימה באופן ידני.
  3. מחכים כמה שניות.
  4. עוברים אל Cloud Run > Services.
  5. לוחצים על שם הפונקציה (censys-data-collector).
  6. לוחצים על הכרטיסייה Logs (יומנים).

  7. מוודאים שהפונקציה בוצעה בהצלחה. מחפשים את הדברים הבאים:

    Collecting events since YYYY-MM-DDTHH:MM:SS+00:00
Collected X logbook events
Collected X risk events
Saved X logbook events to censys/logbook_YYYYMMDD_HHMMSS.json.gz
Saved X risks events to censys/risks_YYYYMMDD_HHMMSS.json.gz
Successfully processed X logbook events and X risk events

  8. עוברים אל Cloud Storage > Buckets (קטגוריות).

  9. לוחצים על שם הקטגוריה.

  10. עוברים לתיקייה עם הקידומת (censys/).

  11. מוודאים שנוצרו קובצי .json.gz חדשים עם חותמת הזמן הנוכחית.

אם מופיעות שגיאות ביומנים:

  • ‫HTTP 401: בדיקת פרטי הכניסה ל-API במשתני הסביבה
  • ‫HTTP 403: מוודאים שלחשבון יש את ההרשאות הנדרשות
  • ‫HTTP 429: הגבלת קצב – הפונקציה תנסה שוב באופן אוטומטי עם השהיה לפני ניסיון חוזר (backoff)
  • חסרים משתני סביבה: צריך לוודא שכל המשתנים הנדרשים מוגדרים

אחזור חשבון השירות של Google SecOps

‫Google SecOps משתמש בחשבון שירות ייחודי כדי לקרוא נתונים מהקטגוריה של GCS. צריך להעניק לחשבון השירות הזה גישה לדלי.

קבלת כתובת האימייל בחשבון השירות

  1. עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על Configure a single feed (הגדרת פיד יחיד).
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Censys logs).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות CENSYS בתור סוג היומן.
  7. לוחצים על קבלת חשבון שירות.

  8. תוצג כתובת האימייל בחשבון שירות ייחודי, לדוגמה:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  9. מעתיקים את כתובת האימייל הזו לשימוש בשלב הבא.

הענקת הרשאות IAM לחשבון השירות של Google SecOps

לחשבון השירות של Google SecOps צריך להיות התפקיד צפייה באובייקט אחסון בקטגוריה של GCS.

  1. עוברים אל Cloud Storage > Buckets (קטגוריות).
  2. לוחצים על שם הקטגוריה.
  3. עוברים לכרטיסייה Permissions.
  4. לוחצים על הענקת גישה.
  5. מספקים את פרטי ההגדרה הבאים:
    • Add principals (הוספת ישויות מורשות): מדביקים את כתובת האימייל בחשבון של חשבון השירות של Google SecOps.
    • הקצאת תפקידים: בוחרים באפשרות צפייה באובייקט אחסון.
  6. לוחצים על Save.

הגדרת פיד ב-Google SecOps להטמעה של יומני Censys

  1. עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על Configure a single feed (הגדרת פיד יחיד).
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Censys logs).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות CENSYS בתור סוג היומן.
  7. לוחצים על הבא.

  8. מציינים ערכים לפרמטרים הבאים של הקלט:

    • כתובת ה-URL של קטגוריית האחסון: מזינים את ה-URI של קטגוריית GCS עם נתיב הקידומת:

      gs://censys-logs/censys/

      • מחליפים את:

        • ‫censys-logs: השם של קטגוריית GCS.
        • ‫censys/: קידומת אופציונלית או נתיב לתיקייה שבה מאוחסנים היומנים (אם לא מציינים כלום, היומנים מאוחסנים בתיקיית הבסיס).

      • לדוגמה:

        • קטגוריית הבסיס: gs://censys-logs/
        • עם קידומת: gs://censys-logs/censys/

    • אפשרות למחיקת המקור: בוחרים את אפשרות המחיקה לפי ההעדפה שלכם:

      • אף פעם: לא נמחקים קבצים אחרי ההעברה (מומלץ לבדיקות).
      • מחיקת קבצים שהועברו: הקבצים נמחקים אחרי שההעברה מסתיימת.

      • מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי שההעברה מסתיימת בהצלחה.

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

    • מרחב השמות של הנכס: מרחב השמות של הנכס.

    • תוויות להוספה: התווית שתתווסף לאירועים מהפיד הזה.

  9. לוחצים על הבא.

  10. בודקים את ההגדרות של הפיד החדש במסך סיום ולוחצים על שליחה.

טבלת מיפוי UDM

שדה ביומן מיפוי UDM היגיון
assetId read_only_udm.principal.asset.hostname אם השדה assetId לא מכיל כתובת IP, הוא ממופה ל-principal.asset.hostname.
assetId read_only_udm.principal.asset.ip אם השדה assetId הוא כתובת IP, הוא ממופה אל principal.asset.ip.
assetId read_only_udm.principal.hostname אם השדה assetId לא מכיל כתובת IP, הוא ממופה ל-principal.hostname.
assetId read_only_udm.principal.ip אם השדה assetId הוא כתובת IP, הוא ממופה ל-principal.ip.
associatedAt read_only_udm.security_result.detection_fields.value השדה associatedAt ממופה אל security_result.detection_fields.value.
autonomousSystem.asn read_only_udm.additional.fields.value.string_value השדה autonomousSystem.asn מומר למחרוזת וממופה ל-additional.fields.value.string_value עם המפתח autonomousSystem_asn.
autonomousSystem.bgpPrefix read_only_udm.additional.fields.value.string_value השדה autonomousSystem.bgpPrefix ממופה ל-additional.fields.value.string_value עם המפתח autonomousSystem_bgpPrefix.
באנר read_only_udm.principal.resource.attribute.labels.value השדה banner ממופה אל principal.resource.attribute.labels.value עם המפתח banner.
ענן read_only_udm.metadata.vendor_name השדה cloud ממופה אל metadata.vendor_name.
comments.refUrl read_only_udm.network.http.referral_url השדה comments.refUrl ממופה ל-network.http.referral_url.
data.cve read_only_udm.additional.fields.value.string_value השדה data.cve ממופה אל additional.fields.value.string_value עם המפתח data_cve.
data.cvss read_only_udm.additional.fields.value.string_value השדה data.cvss ממופה אל additional.fields.value.string_value עם המפתח data_cvss.
data.ipAddress read_only_udm.principal.asset.ip אם השדה data.ipAddress לא שווה לשדה assetId, הוא ממופה ל-principal.asset.ip.
data.ipAddress read_only_udm.principal.ip אם השדה data.ipAddress לא שווה לשדה assetId, הוא ממופה ל-principal.ip.
data.location.city read_only_udm.principal.location.city אם השדה location.city ריק, השדה data.location.city ממופה אל principal.location.city.
data.location.countryCode read_only_udm.principal.location.country_or_region אם השדה location.country ריק, השדה data.location.countryCode ממופה אל principal.location.country_or_region.
data.location.latitude read_only_udm.principal.location.region_coordinates.latitude אם השדות location.coordinates.latitude ו-location.geoCoordinates.latitude ריקים, השדה data.location.latitude מומר למספר עשרוני וממופה ל-principal.location.region_coordinates.latitude.
data.location.longitude read_only_udm.principal.location.region_coordinates.longitude אם השדות location.coordinates.longitude ו-location.geoCoordinates.longitude ריקים, השדה data.location.longitude מומר למספר נקודה צפה וממופה ל-principal.location.region_coordinates.longitude.
data.location.province read_only_udm.principal.location.state אם השדה location.province ריק, השדה data.location.province ממופה אל principal.location.state.
data.mailServers read_only_udm.additional.fields.value.list_value.values.string_value כל רכיב במערך data.mailServers ממופה לרשומה נפרדת של additional.fields עם המפתח Mail Servers והערך list_value.values.string_value שמוגדר לערך הרכיב.
data.names.forwardDns[].name read_only_udm.network.dns.questions.name כל רכיב במערך data.names.forwardDns ממופה לרשומה נפרדת של network.dns.questions עם השדה name שמוגדר לשדה השם של הרכיב.
data.nameServers read_only_udm.additional.fields.value.list_value.values.string_value כל רכיב במערך data.nameServers ממופה לרשומה נפרדת של additional.fields עם המפתח Name nameServers והערך value.list_value.values.string_value שמוגדר לערך הרכיב.
data.protocols[].transportProtocol read_only_udm.network.ip_protocol אם השדה data.protocols[].transportProtocol הוא אחד מהערכים הבאים: TCP,‏ EIGRP,‏ ESP,‏ ETHERIP,‏ GRE,‏ ICMP,‏ IGMP,‏ IP6IN4,‏ PIM,‏ UDP או VRRP, הוא ממופה ל-network.ip_protocol.
data.protocols[].transportProtocol read_only_udm.principal.resource.attribute.labels.value השדה data.protocols[].transportProtocol ממופה אל principal.resource.attribute.labels.value עם המפתח data_protocols {index}.
http.request.headers[].key, http.request.headers[].value.headers.0 read_only_udm.network.http.user_agent אם השדה http.request.headers[].key הוא User-Agent, השדה התואם http.request.headers[].value.headers.0 ממופה אל network.http.user_agent.
http.request.headers[].key, http.request.headers[].value.headers.0 read_only_udm.network.http.parsed_user_agent אם השדה http.request.headers[].key הוא User-Agent, השדה התואם http.request.headers[].value.headers.0 מנותח כמחרוזת של סוכן משתמש וממופה ל-network.http.parsed_user_agent.
http.request.headers[].key, http.request.headers[].value.headers.0 read_only_udm.principal.resource.attribute.labels.key, read_only_udm.principal.resource.attribute.labels.value לכל רכיב במערך http.request.headers, שדה המפתח ממופה ל-principal.resource.attribute.labels.key ושדה הערך value.headers.0 ממופה ל-principal.resource.attribute.labels.value.
http.request.uri read_only_udm.principal.asset.hostname החלק של שם המארח בשדה http.request.uri מחולץ וממופה אל principal.asset.hostname.
http.request.uri read_only_udm.principal.hostname החלק של שם המארח בשדה http.request.uri מחולץ וממופה ל-principal.hostname.
http.response.body read_only_udm.principal.resource.attribute.labels.value השדה http.response.body ממופה אל principal.resource.attribute.labels.value עם המפתח http_response_body.
http.response.headers[].key, http.response.headers[].value.headers.0 read_only_udm.target.hostname אם השדה http.response.headers[].key הוא Server, השדה המתאים http.response.headers[].value.headers.0 ממופה אל target.hostname.
http.response.headers[].key, http.response.headers[].value.headers.0 read_only_udm.principal.resource.attribute.labels.key, read_only_udm.principal.resource.attribute.labels.value לכל רכיב במערך http.response.headers, השדה key ממופה ל-principal.resource.attribute.labels.key והשדה value.headers.0 ממופה ל-principal.resource.attribute.labels.value.
http.response.statusCode read_only_udm.network.http.response_code השדה http.response.statusCode מומר למספר שלם וממופה ל-network.http.response_code.
ip read_only_udm.target.asset.ip השדה ip ממופה אל target.asset.ip.
ip read_only_udm.target.ip השדה ip ממופה ל-target.ip.
isSeed read_only_udm.additional.fields.value.string_value השדה isSeed מומר למחרוזת וממופה ל-additional.fields.value.string_value עם המפתח isSeed.
location.city read_only_udm.principal.location.city השדה location.city ממופה אל principal.location.city.
location.continent read_only_udm.additional.fields.value.string_value השדה location.continent ממופה אל additional.fields.value.string_value עם המפתח location_continent.
location.coordinates.latitude read_only_udm.principal.location.region_coordinates.latitude השדה location.coordinates.latitude מומר למספר עשרוני וממופה ל-principal.location.region_coordinates.latitude.
location.coordinates.longitude read_only_udm.principal.location.region_coordinates.longitude השדה location.coordinates.longitude מומר למספר עשרוני ומופה ל-principal.location.region_coordinates.longitude.
location.country read_only_udm.principal.location.country_or_region השדה location.country ממופה אל principal.location.country_or_region.
location.geoCoordinates.latitude read_only_udm.principal.location.region_coordinates.latitude אם השדה location.coordinates.latitude ריק, השדה location.geoCoordinates.latitude מומר למספר עשרוני וממופה אל principal.location.region_coordinates.latitude.
location.geoCoordinates.longitude read_only_udm.principal.location.region_coordinates.longitude אם השדה location.coordinates.longitude ריק, השדה location.geoCoordinates.longitude מומר למספר עשרוני ומופה אל principal.location.region_coordinates.longitude.
location.postalCode read_only_udm.additional.fields.value.string_value השדה location.postalCode ממופה אל additional.fields.value.string_value עם המפתח Postal code.
location.province read_only_udm.principal.location.state השדה location.province ממופה אל principal.location.state.
פעולה read_only_udm.security_result.action_details השדה operation ממופה אל security_result.action_details.
perspectiveId read_only_udm.principal.group.product_object_id השדה perspectiveId ממופה ל-principal.group.product_object_id.
יציאה read_only_udm.principal.port השדה port מומר למספר שלם וממופה ל-principal.port.
‫risks[].severity, risks[].title read_only_udm.security_result.category_details השדה risks[].severity משורשר לשדה risks[].title וממופה ל-security_result.category_details.
serviceName read_only_udm.network.application_protocol אם השדה serviceName הוא HTTP או HTTPS, הוא ממופה ל-network.application_protocol.
sourceIp read_only_udm.principal.asset.ip השדה sourceIp ממופה ל-principal.asset.ip.
sourceIp read_only_udm.principal.ip השדה sourceIp ממופה ל-principal.ip.
חותמת זמן read_only_udm.metadata.event_timestamp השדה של חותמת הזמן מנותח כחותמת זמן וממופה אל metadata.event_timestamp.
transportFingerprint.id read_only_udm.metadata.product_log_id השדה transportFingerprint.id מומר למחרוזת וממופה אל metadata.product_log_id.
transportFingerprint.raw read_only_udm.additional.fields.value.string_value השדה transportFingerprint.raw ממופה אל additional.fields.value.string_value עם המפתח transportFingerprint_raw.
סוג read_only_udm.metadata.product_event_type השדה type ממופה אל metadata.product_event_type.
- read_only_udm.metadata.product_name הערך CENSYS_ASM מוקצה ל-metadata.product_name.
- read_only_udm.metadata.vendor_name הערך CENSYS מוקצה ל-metadata.vendor_name.
- read_only_udm.metadata.event_type סוג האירוע נקבע על סמך נוכחות של שדות ספציפיים: NETWORK_CONNECTION אם has_princ_machine_id ו-has_target_machine הם true ו-has_network_flow הוא false, ‏ NETWORK_DNS אם has_network_flow הוא true, ‏ STATUS_UPDATE אם has_princ_machine_id הוא true, ‏ ו-GENERIC_EVENT בכל מקרה אחר.

יומן שינויים

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

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