איסוף יומנים של ReliaQuest GreyMatter DRP Indicators (לשעבר Digital Shadows)

גרסת המנתח: 2.0

נתמך ב:

במסמך הזה מוסבר איך להטמיע ב-Google Security Operations יומני אינדיקטורים של ReliaQuest GreyMatter DRP (לשעבר Digital Shadows) באמצעות Amazon S3.

‫ReliaQuest GreyMatter DRP היא פלטפורמה להגנה מפני סיכונים דיגיטליים, שעוקבת באופן רציף אחרי איומים חיצוניים, חשיפות נתונים והתחזות למותגים ברשת הפתוחה, ברשת העמוקה, בהדארקנט וברשתות החברתיות, ומזהה אותם. הוא מספק מודיעין איומי סייבר, התראות על אירועים וסימנים מחשידים (IOC) כדי לעזור לארגונים לזהות סיכונים דיגיטליים ולצמצם אותם.

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

חשוב לוודא שיש לכם את הדברים הבאים:

  • מכונה של Google SecOps
  • גישה מיוחדת לפורטל Digital Shadows Indicators
  • גישה מורשית ל-AWS‏ (S3, ‏ IAM)
  • מינוי פעיל ל-Digital Shadows Indicators עם גישה מופעלת ל-API

איסוף פרטי הכניסה של Digital Shadows Indicators API

  1. נכנסים ל-Digital Shadows Indicators Portal בכתובת https://portal-digitalshadows.com.
  2. עוברים אל הגדרות > פרטי כניסה ל-API.
  3. אם אין לכם מפתח API קיים, לוחצים על יצירת לקוח API חדש או על יצירת מפתח API.
  4. מעתיקים ושומרים במיקום מאובטח את הפרטים הבאים:
    • ‫API Key: מפתח ה-API שלכם, שמורכב מ-6 תווים
    • ‫API Secret: ערך ה-API Secret שלכם, שמורכב מ-32 תווים
    • מזהה חשבון: מזהה החשבון שלכם (מוצג בפורטל או מסופק על ידי נציג Digital Shadows)
    • כתובת ה-URL הבסיסית של ה-API: https://api.searchlight.app/v1 או https://portal-digitalshadows.com/api/v1 (בהתאם לאזור של הדייר)

הגדרת קטגוריית AWS S3 ו-IAM ל-Google SecOps

  1. יוצרים קטגוריה של Amazon S3 לפי המדריך למשתמש: יצירת קטגוריה
  2. שומרים את שם הקטגוריה ואת האזור שלה לעיון בעתיד (לדוגמה, digital-shadows-logs).
  3. יוצרים משתמש לפי המדריך למשתמש: יצירת משתמש IAM.
  4. בוחרים את המשתמש שנוצר.
  5. לוחצים על הכרטיסייה פרטי כניסה מאובטחים.
  6. לוחצים על Create Access Key בקטע Access Keys.
  7. בקטע תרחיש לדוגמה, בוחרים באפשרות שירות של צד שלישי.
  8. לוחצים על הבא.
  9. אופציונלי: מוסיפים תג תיאור.
  10. לוחצים על יצירת מפתח גישה.
  11. לוחצים על Download .csv file כדי לשמור את Access Key ואת Secret Access Key לשימוש עתידי.
  12. לוחצים על סיום.
  13. לוחצים על הכרטיסייה הרשאות.
  14. בקטע מדיניות הרשאות, לוחצים על הוספת הרשאות.
  15. לוחצים על הוספת הרשאות.
  16. בוחרים באפשרות Attach policies directly.
  17. מחפשים את המדיניות AmazonS3FullAccess.
  18. בוחרים את המדיניות.
  19. לוחצים על הבא.
  20. לוחצים על הוספת הרשאות.

הגדרת המדיניות והתפקיד ב-IAM להעלאות ל-S3

  1. במסוף AWS, עוברים אל IAM > Policies > Create policy > הכרטיסייה JSON.
  2. מעתיקים ומדביקים את המדיניות שבהמשך.
  3. קובץ JSON של המדיניות (צריך להחליף את digital-shadows-logs אם הזנתם שם אחר לקטגוריה):

    {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "AllowPutObjects",
                "Effect": "Allow",
                "Action": "s3:PutObject",
                "Resource": "arn:aws:s3:::digital-shadows-logs/*"
            },
            {
                "Sid": "AllowGetStateObject",
                "Effect": "Allow",
                "Action": "s3:GetObject",
                "Resource": "arn:aws:s3:::digital-shadows-logs/digital-shadows/state.json"
            }
        ]
    }
    
  4. לוחצים על Next > Create policy.

  5. עוברים אל IAM > Roles > Create role > AWS service > Lambda.

  6. מצרפים את המדיניות החדשה שנוצרה.

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

יצירת פונקציית Lambda

  1. ב-AWS Console, עוברים אל Lambda > Functions > Create function.
  2. לוחצים על יצירה מאפס.
  3. ממלאים את פרטי ההגדרה הבאים:

    הגדרה ערך
    שם DigitalShadowsCollector
    זמן ריצה Python 3.13
    ארכיטקטורה x86_64
    תפקיד ביצוע DigitalShadowsLambdaRole
  4. אחרי שיוצרים את הפונקציה, פותחים את הכרטיסייה Code, מוחקים את ה-stub ומדביקים את הקוד שבהמשך (DigitalShadowsCollector.py).

    import urllib3
    import json
    import boto3
    import os
    import base64
    import logging
    import time
    from datetime import datetime, timedelta, timezone
    from urllib.parse import urlencode
    
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    
    HTTP = urllib3.PoolManager(retries=False)
    storage_client = boto3.client('s3')
    
    def _basic_auth_header(key: str, secret: str) -> str:
        token = base64.b64encode(f"{key}:{secret}".encode("utf-8")).decode("utf-8")
        return f"Basic {token}"
    
    def _load_state(bucket, key, default_days=30) -> str:
        """Return ISO8601 checkpoint (UTC)."""
        try:
            response = storage_client.get_object(Bucket=bucket, Key=key)
            state_data = response['Body'].read().decode('utf-8')
            state = json.loads(state_data)
            ts = state.get("last_timestamp")
            if ts:
                return ts
        except storage_client.exceptions.NoSuchKey:
            logger.info("No previous state found, starting from default lookback")
        except Exception as e:
            logger.warning(f"State read error: {e}")
        return (datetime.now(timezone.utc) - timedelta(days=default_days)).isoformat()
    
    def _save_state(bucket, key, ts: str) -> None:
        storage_client.put_object(
            Bucket=bucket,
            Key=key,
            Body=json.dumps({"last_timestamp": ts}),
            ContentType="application/json"
        )
    
    def _get_json(url: str, headers: dict, params: dict, backoff_s=2, max_retries=3) -> dict:
        qs = f"?{urlencode(params)}" if params else ""
        for attempt in range(max_retries):
            r = HTTP.request("GET", f"{url}{qs}", headers=headers)
            if r.status == 200:
                return json.loads(r.data.decode("utf-8"))
            if r.status in (429, 500, 502, 503, 504):
                wait = backoff_s * (2 ** attempt)
                logger.warning(f"HTTP {r.status} from DS API, retrying in {wait}s")
                time.sleep(wait)
                continue
            raise RuntimeError(f"DS API error {r.status}: {r.data[:200]}")
        raise RuntimeError("Exceeded retry budget for DS API")
    
    def _collect(api_base, headers, path, since_ts, account_id, page_size, max_pages, time_param):
        items = []
        for page in range(max_pages):
            params = {
                "limit": page_size,
                "offset": page * page_size,
                time_param: since_ts,
            }
            if account_id:
                params["account-id"] = account_id
            data = _get_json(f"{api_base}/{path}", headers, params)
            batch = data.get("items") or data.get("data") or []
            if not batch:
                break
            items.extend(batch)
            if len(batch) < page_size:
                break
        return items
    
    def lambda_handler(event, context):
        bucket_name = os.environ["S3_BUCKET"]
        api_key = os.environ["DS_API_KEY"]
        api_secret = os.environ["DS_API_SECRET"]
        prefix = os.environ.get("S3_PREFIX", "digital-shadows")
        state_key = os.environ.get("STATE_KEY", "digital-shadows/state.json")
        api_base = os.environ.get("API_BASE", "https://api.searchlight.app/v1")
        account_id = os.environ.get("DS_ACCOUNT_ID", "")
        page_size = int(os.environ.get("PAGE_SIZE", "100"))
        max_pages = int(os.environ.get("MAX_PAGES", "10"))
    
        try:
            last_ts = _load_state(bucket_name, state_key)
            logger.info(f"Checkpoint: {last_ts}")
    
            headers = {
                "Authorization": _basic_auth_header(api_key, api_secret),
                "Accept": "application/json",
                "User-Agent": "Chronicle-DigitalShadows-S3/1.0",
            }
    
            records = []
    
            incidents = _collect(
                api_base, headers, "incidents", last_ts, account_id,
                page_size, max_pages, time_param="published-after"
            )
            for incident in incidents:
                incident['_source_type'] = 'incident'
            records.extend(incidents)
    
            intel_incidents = _collect(
                api_base, headers, "intel-incidents", last_ts, account_id,
                page_size, max_pages, time_param="published-after"
            )
            for intel in intel_incidents:
                intel['_source_type'] = 'intelligence_incident'
            records.extend(intel_incidents)
    
            indicators = _collect(
                api_base, headers, "indicators", last_ts, account_id,
                page_size, max_pages, time_param="lastUpdated-after"
            )
            for indicator in indicators:
                indicator['_source_type'] = 'ioc'
            records.extend(indicators)
    
            if records:
                newest = max(
                    (r.get("updated") or r.get("raised") or r.get("lastUpdated") or last_ts)
                    for r in records
                )
                key = f"{prefix}/digital_shadows_{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.json"
                body = "\n".join(json.dumps(r, separators=(",", ":")) for r in records)
                storage_client.put_object(
                    Bucket=bucket_name,
                    Key=key,
                    Body=body,
                    ContentType="application/x-ndjson"
                )
                _save_state(bucket_name, state_key, newest)
                msg = f"Wrote {len(records)} records to s3://{bucket_name}/{key}"
            else:
                msg = "No new records"
    
            logger.info(msg)
            return {'statusCode': 200, 'body': json.dumps({'message': msg, 'records': len(records) if records else 0})}
    
        except Exception as e:
            logger.error(f"Error processing logs: {str(e)}")
            raise
    
  5. עוברים אל Configuration > Environment variables > Edit > Add new environment variable.

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

משתני סביבה

מפתח ערך לדוגמה
S3_BUCKET digital-shadows-logs
S3_PREFIX digital-shadows/
STATE_KEY digital-shadows/state.json
DS_API_KEY ‫ABC123 (מפתח ה-API שלכם, שמורכב מ-6 תווים)
DS_API_SECRET your-32-character-api-secret
API_BASE https://api.searchlight.app/v1
DS_ACCOUNT_ID your-account-id
PAGE_SIZE 100
MAX_PAGES 10
  1. אחרי שיוצרים את הפונקציה, נשארים בדף שלה (או פותחים את Lambda > Functions > DigitalShadowsCollector).
  2. בוחרים את הכרטיסייה Configuration.
  3. בחלונית General configuration לוחצים על Edit.
  4. משנים את הערך של Timeout ל-5 minutes (300 seconds) ולוחצים על Save.

יצירת לוח זמנים ב-EventBridge

  1. עוברים אל Amazon EventBridge > Scheduler > Create schedule.
  2. מזינים את פרטי ההגדרה הבאים:
    • לו"ז חזרה: תדירות (1 hour)
    • Target: פונקציית Lambda שלכם DigitalShadowsCollector
    • שם: DigitalShadowsCollector-1h
  3. לוחצים על יצירת לוח זמנים.

הגדרת פיד ב-Google SecOps כדי להטמיע יומני אינדיקטורים של Digital Shadows

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. בדף הבא, לוחצים על הגדרת פיד יחיד.
  4. מזינים שם ייחודי בשדה שם הפיד.
  5. בוחרים באפשרות Amazon S3 V2 בתור סוג המקור.
  6. בוחרים באפשרות Digital Shadows Indicators בתור Log type.
  7. לוחצים על הבא ואז על שליחה.
  8. מציינים ערכים בשדות הבאים:

    • S3 URI:‏ s3://digital-shadows-logs/digital-shadows/
    • אפשרות מחיקת מקור: בוחרים את אפשרות המחיקה לפי ההעדפה שלכם.
    • גיל הקובץ המקסימלי: כולל קבצים ששונו במספר הימים האחרונים (ברירת המחדל היא 180 ימים)
    • מזהה מפתח הגישה: מפתח גישה של משתמש עם גישה לקטגוריית S3
    • מפתח גישה סודי: מפתח סודי של משתמש עם גישה לקטגוריית S3
    • מרחב השמות של הנכס: מרחב השמות של הנכס
    • תוויות הטמעה: התווית שתתווסף לאירועים מהפיד הזה
  9. לוחצים על הבא ואז על שליחה.

טבלת מיפוי UDM

שדה ביומן מיפוי UDM Logic (פונקציה לוגית)
value entity.entity.file.md5 צריך להגדיר אם type == "MD5"
value entity.entity.file.sha1 צריך להגדיר אם type == "SHA1"
value entity.entity.file.sha256 צריך להגדיר אם הסוג הוא SHA256
value entity.entity.hostname צריך להגדיר אם type == "HOST"
value entity.entity.ip הערך מועתק ישירות אם type == "IP"
value entity.entity.url צריך להגדיר אם הסוג הוא "URL"
value entity.entity.user.email_addresses הערך מועתק ישירות אם הסוג הוא EMAIL
סוג entity.metadata.entity_type צריך להגדיר את הערך "DOMAIN_NAME" אם הסוג הוא "HOST", את הערך "IP_ADDRESS" אם הסוג הוא "IP", את הערך "URL" אם הסוג הוא "URL", את הערך "USER" אם הסוג הוא "EMAIL", את הערך "FILE" אם הסוג הוא ["SHA1","SHA256","MD5"], אחרת צריך להגדיר את הערך "UNKNOWN_ENTITYTYPE"
lastUpdated entity.metadata.interval.start_time ההמרה מ-ISO8601 לחותמת זמן מתבצעת אם השדה לא ריק
id entity.metadata.product_entity_id הערך מועתק ישירות אם הוא לא ריק
attributionTag.id, ‏ attributionTag.name, ‏ attributionTag.type entity.metadata.threat.about.labels מוזג עם אובייקטים {key: tag field name, value: tag value} אם לא ריק
sourceType entity.metadata.threat.category_details הערך הועתק ישירות
entity.metadata.threat.threat_feed_name הגדרה ל "אינדיקטורים"
id entity.metadata.threat.threat_id הערך מועתק ישירות אם הוא לא ריק
sourceIdentifier entity.metadata.threat.url_back_to_product הערך הועתק ישירות
entity.metadata.product_name הגדרה ל "אינדיקטורים"
entity.metadata.vendor_name הגדרה ל "צללים דיגיטליים"

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