Hinweis:

Dieses Tutorial erfordert Zugriff auf Oracle Cloud. Informationen zur Registrierung für einen kostenlosen Account finden Sie unter Erste Schritte mit Oracle Cloud Infrastructure Free Tier.
Es verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, -Mandanten und -Compartments. Ersetzen Sie diese Werte nach Abschluss der Übung durch Werte, die für Ihre Cloud-Umgebung spezifisch sind.

Oracle Cloud Guard-Probleme mit Oracle Cloud Infrastructure Functions per E-Mail senden

Einführung

Heute stehen Cybersicherheitsteams in allen Branchen vor der komplexen Herausforderung, einen soliden Sicherheitsstatus beizubehalten und gleichzeitig mit dem dynamischen Charakter von Cloud-Umgebungen umzugehen. Mit unzähligen Ressourcen, Konfigurationen und sich entwickelnden Bedrohungen ist die zeitnahe Verfolgung und Behebung von Problemen von entscheidender Bedeutung. Bei Oracle wissen wir, wie wichtig es ist, Unternehmen mit Tools auszustatten, um ihr Sicherheitsmanagement zu optimieren und ihnen dabei zu helfen, diese Herausforderungen direkt zu bewältigen. Oracle Cloud Guard bietet robuste Funktionen, mit denen Unternehmen das Cloud-Sicherheitsmanagement vereinfachen können. Dabei können sie von der bloßen Erkennung von Sicherheitslücken zur automatischen Verteilung von Problemen über Teams hinweg zur rechtzeitigen Lösung wechseln.

In diesem Tutorial wird eine automatisierte Lösung beschrieben, die native Services von OCI nutzt, mit der Sicherheitsteams detaillierte Oracle Cloud Guard-Sicherheitsberichte direkt per E-Mail erhalten und teilen können. Dieser Ansatz reduziert manuelle Eingriffe, erleichtert die kontinuierliche Überwachung und stellt eine proaktive Haltung in der Cloud-Sicherheit sicher.

Bild der High-Level-Architektur

Zielsetzung

Erhalten Sie alle offenen Probleme von Oracle Cloud Guard in einer E-Mail, die an die entsprechenden Teams verteilt werden kann, um den Weg zur Lösung zu optimieren.

Voraussetzungen

Zugriff auf einen Oracle Cloud Infrastructure-(OCI-)Mandanten.
Berechtigungen zur Verwaltung von Oracle Cloud Guard, OCI Functions, OCI Email Delivery-Service, OCI Vault und OCI Resource Scheduler.

Aufgabe 1: Erforderliche Policys und Oracle Cloud Infrastructure Identity and Access Management-(OCI IAM-)Berechtigungen einrichten

Jede Komponente dieser Lösung muss Zugriff auf die OCI-Ressourcen haben, mit denen sie interagiert.

Resource Scheduler Policy: Der Scheduler darf die Funktion nach einem definierten Zeitplan ausführen. Weitere Informationen finden Sie unter Beispiel-Policys.
Funktions-Policy: Erteilen Sie der Funktionsberechtigung, Secrets aus OCI Vault zu lesen und Oracle Cloud Guard-Probleme abzurufen. Weitere Informationen finden Sie unter Details zu Functions.

Aufgabe 2: OCI Email Delivery-Service konfigurieren

Richten Sie den OCI Email Delivery-Service ein, indem Sie eine E-Mail-Adresse für den genehmigten Absender erstellen, die zum Senden von Berichten verwendet wird. Weitere Informationen finden Sie unter Genehmigten Absender erstellen.
Generieren Sie Simple Mail Transfer Protocol-(SMTP-)Zugangsdaten für den E-Mail-Account, indem Sie einen dedizierten Benutzer mit begrenzten SMTP-Zugriffsberechtigungen erstellen.
1. Erstellen Sie einen OCI-IAM-Benutzer. Weitere Informationen finden Sie unter Benutzer erstellen.
2. Informationen zum Bearbeiten von Benutzerfunktionen finden Sie unter Benutzerfunktionen bearbeiten.
3. Informationen zum Erstellen von SMTP-ID-Daten finden Sie unter Erstellen von SMTP-ID-Daten.

Aufgabe 3: SMTP-Zugangsdaten in OCI Vault speichern

Speichern Sie SMTP-Zugangsdaten mit OCI Vault sicher. Dadurch wird eine zusätzliche Sicherheitsebene hinzugefügt, indem sensible Informationen außerhalb der Funktion aufbewahrt werden.

Richten Sie einen OCI Vault ein. Weitere Informationen finden Sie unter Vault erstellen.
Informationen zum Erstellen eines Master-Verschlüsselungsschlüssels finden Sie unter Master-Verschlüsselungsschlüssel erstellen.
Informationen zum Erstellen eines Secrets finden Sie unter Secret in einem Vault erstellen.

Bild der Vault-Konfiguration

Aufgabe 4: Funktion entwickeln und bereitstellen

Diese Funktion ruft ungelöste Sicherheitsprobleme ab, die im letzten Jahr ermittelt wurden. Sie formatiert die Daten auf Basis von Parametern wie Risikostufe und Erkennungszeit in einem strukturierten Bericht und sendet sie dann per E-Mail als CSV-Anhang. Weitere Informationen finden Sie unter Funktionen bereitstellen.

Im Folgenden finden Sie eine Übersicht über die wichtigsten Funktionsschritte:

Rufen Sie ungelöste Probleme aus Oracle Cloud Guard ab.
Organisieren und formatieren Sie die Probleme nach Schweregrad.
Generieren Sie einen CSV-Bericht, und formatieren Sie den Bericht.
Rufen Sie die SMTP-Zugangsdaten aus dem Vault ab.
Senden Sie die E-Mail an bestimmte Empfänger mit CSV als Anhang.

Mit den serverlosen Funktionsfunktionen von OCI kann dieser Bericht angepasst werden, um maximale Klarheit über kritische Sicherheitsbereiche für Cybersicherheitsteams zu bieten.

func.py:

import oci
import io
import smtplib
import logging
import base64

from oci.pagination import list_call_get_all_results
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders
from email.mime.text import MIMEText
from openpyxl import Workbook
from datetime import datetime, timedelta, timezone
from openpyxl.styles import Font

# Retrieve secrets from OCI Vault
def get_secret_value(secret_ocid):
    print(f"Retrieving secret for OCID: {secret_ocid}")
    signer = oci.auth.signers.get_resource_principals_signer()
    secrets_client = oci.secrets.SecretsClient({}, signer=signer)

    try:
        secret_content = secrets_client.get_secret_bundle(secret_ocid)
        secret_data = secret_content.data.secret_bundle_content.content
        secret_value = base64.b64decode(secret_data).decode('utf-8')
        return secret_value
    except Exception as e:
        print(f"Failed to retrieve secret: {e}")
        raise

# Format the CSV
def get_font_style(risk_level, time_condition):
    color_map = {
        "CRITICAL": "8B0000",
        "HIGH": "FF8C00",
        "MEDIUM": "006400",
        "LOW": "00008B",
        "MINOR": "000000"
    }
    font_color = color_map.get(risk_level, "000000")
    is_bold = time_condition
    return Font(color=font_color, bold=is_bold)

def get_clients_with_resource_principal():
    signer = oci.auth.signers.get_resource_principals_signer()
    cloud_guard_client = oci.cloud_guard.CloudGuardClient({}, signer=signer)
    return cloud_guard_client

def send_email_via_oci(subject, body, email, attachment, username_secret_ocid, password_secret_ocid, from_email, smtp_endpoint, smtp_port):
    msg = MIMEMultipart()
    msg['Subject'] = subject
    msg['From'] = from_email
    msg['To'] = email

    msg.attach(MIMEText(body, 'plain'))

    today_date = datetime.today().strftime('%Y-%m-%d')
    filename = f"CloudGuardReport_{today_date}.xlsx"
    part = MIMEBase('application', "octet-stream")
    part.set_payload(attachment)
    encoders.encode_base64(part)
    part.add_header('Content-Disposition', f"attachment; filename={filename}")
    msg.attach(part)

    try:
        username = get_secret_value(username_secret_ocid)
        password = get_secret_value(password_secret_ocid)

        server = smtplib.SMTP(smtp_endpoint, smtp_port)
        server.starttls()
        server.login(username, password)
        server.sendmail(msg['From'], [msg['To']], msg.as_string())
        server.quit()
        print("Email sent successfully.")
    except Exception as e:
        print(f"Failed to send email: {e}")
        raise

def handler(ctx, data: io.BytesIO=None):
    try:
        cfg = ctx.Config()
        compartment_id = cfg["compartment-id"]
        from_email = cfg["from-email"]
        email = cfg["to-email"]
        smtp_endpoint = cfg["smtp-endpoint"]
        smtp_port = cfg["smtp-port"]
        username_secret_ocid = cfg["smtp-username-secret-ocid"]
        password_secret_ocid = cfg["smtp-password-secret-ocid"]
        cg_access_level = cfg["cloudguard-access-level"]

        cloud_guard_client = get_clients_with_resource_principal()

        current_time = datetime.now(timezone.utc)
        time_last_7_days = current_time - timedelta(days=7)
        formatted_time_one_year_ago = (current_time - timedelta(days=365)).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
        formatted_time_last_7_days = time_last_7_days.strftime("%Y-%m-%dT%H:%M:%S.%fZ")

        # List problems
        problem_response = list_call_get_all_results(
            cloud_guard_client.list_problems,
            compartment_id,
            compartment_id_in_subtree=True,
            access_level=cg_access_level,
            time_first_detected_greater_than_or_equal_to=formatted_time_one_year_ago,
            time_last_detected_greater_than_or_equal_to=formatted_time_last_7_days
        ).data

        if not problem_response:
            logging.info("No open problems found.")
            return {"statusCode": 200, "body": "No open problems found."}

        print(f"Found {len(problem_response)} problems")

        # Sort problems by Risk Level
        risk_level_order = {"CRITICAL": 1, "HIGH": 2, "MEDIUM": 3, "LOW": 4, "MINOR": 5}
        problem_response.sort(key=lambda x: risk_level_order.get(x.risk_level, 6))

        # Create a workbook and select active worksheet
        wb = Workbook()
        ws = wb.active
        ws.title = "Cloud Guard Problems"

        ws.append([
            "Region", "ID", "Resource Type", "Resource Name", "Risk Level", 
            "Detector", "Rule Display Name", "Rule Description", "Rule Recommendation", 
            "Resource ID", "Time First Detected", "Time Last Detected"
        ])

        # Iterate through the problems
        for problem in problem_response:
            try:
                detector_rule_response = cloud_guard_client.get_detector_rule(problem.detector_id, problem.detector_rule_id).data
                rule_description = detector_rule_response.description
                detector = detector_rule_response.detector
                rule_display_name = detector_rule_response.display_name
                rule_recommendation = detector_rule_response.recommendation
            except Exception as e:
                logging.error(f"Error fetching detector rule details for problem {problem.id}: {str(e)}")
                rule_description, detector, rule_display_name, rule_recommendation = "N/A", "N/A", "N/A", "N/A"

            problem_details = [
                problem.region, problem.id, problem.resource_type, problem.resource_name, 
                problem.risk_level, detector, rule_display_name, rule_description, 
                rule_recommendation, problem.resource_id,
                problem.time_first_detected.replace(tzinfo=None) if problem.time_first_detected else None, 
                problem.time_last_detected.replace(tzinfo=None) if problem.time_last_detected else None
            ]

            # Add row to worksheet
            ws.append(problem_details)

            # Apply format
            time_condition = problem.time_last_detected > problem.time_first_detected if problem.time_last_detected and problem.time_first_detected else False
            font_style = get_font_style(problem.risk_level, time_condition)
            row_number = ws.max_row
            for cell in ws[row_number]:
                cell.font = font_style

        virtual_workbook = io.BytesIO()
        wb.save(virtual_workbook)
        virtual_workbook.seek(0)

        # Send email
        send_email_via_oci("OCI Cloud Guard Report", "Find attached the OCI Cloud Guard Report.", email, virtual_workbook.getvalue(), username_secret_ocid, password_secret_ocid, from_email, smtp_endpoint, smtp_port)

        return {"statusCode": 200, "body": "Email sent successfully."}

    except Exception as e:
        logging.error(f"Error: {str(e)}")
        return {"statusCode": 500, "body": f"Error: {str(e)}"}

func.yaml:

schema_version: 20180708
name: oci-cloud-guard-problems
version: 0.0.1
runtime: python
build_image: fnproject/python:3.9-dev
run_image: fnproject/python:3.9
entrypoint: /python/bin/fdk /function/func.py handler
memory: 256
config:
compartment-id: Provide a compartment ID here
to-email: Provide a valid email ID here
from-email: Provide the Approved Sender Email ID created in the Email Delivery Service
smtp-username-secret-ocid: Provide the SMTP Username Secret OCID
smtp-password-secret-ocid: Provide the SMTP Password Secret OCID
smtp-endpoint: Provide the SMTP endpoint from the Email Delivery Service
smtp-port: 587
cloudguard-access-level: ACCESSIBLE or RESTRICTED

requirements.txt:
```
fdk
oci
openpyxl
```

Bild der Funktionskonfiguration

Aufgabe 5: Funktion mit OCI Resource Scheduler planen

Die letzte Aufgabe besteht darin, die Ausführung der Funktion mit OCI Resource Scheduler zu automatisieren. Diese Konfiguration kann wöchentlich oder in einem benutzerdefinierten Intervall ausgeführt werden, um zeitnahe und konsistente Sicherheitsberichte sicherzustellen. Weitere Informationen finden Sie unter Erstellen von Zeitplänen.

Bild der Scheduler-Konfiguration

Geben Sie die folgenden erforderlichen Informationen ein, um die Funktion auszuführen.

Bevor Sie die Funktion bereitstellen, erfassen Sie die folgenden Konfigurationsdetails. Diese Eingaben werden je nach Deployment-Methode in der Funktionskonfigurationsdatei (func.yaml) oder direkt in der OCI-Konsole bereitgestellt.
- Compartment-ID: Dies ist Ihre Mandanten-ID, in der Oracle Cloud Guard aktiviert ist.
- Von E-Mail: Die genehmigte Absender-E-Mail, die Sie im OCI Email Delivery-Service erstellt haben.
- An E-Mail: Die E-Mail-Adresse, an die der Bericht gesendet wird.
- SMTP-Endpunkt: Um ihn zu finden, gehen Sie zu Email Delivery und Konfiguration.
- SMTP-Port: In der Regel 587 oder 25, wie in der OCI Email Delivery-Servicekonfiguration angegeben.
- Secret-OCID für SMTP-Benutzername: Die OCID für den SMTP-Benutzernamen, die sicher in OCI Vault gespeichert ist.
- Secret-OCID für SMTP-Kennwort: Die OCID für das SMTP-Kennwort, das sicher in OCI Vault gespeichert ist.
- Cloud Guard-Zugriffsebene: Definiert die Zugriffsebene für Ressourcen (ACCESSIBLE oder RESTRICTED). Der Standardwert ist ACCESSIBLE.
Wir erhalten eine Beispielausgabe, die ein verwertbarer Oracle Cloud Guard-Bericht ist.

Dieser Oracle Cloud Guard-Bericht bietet einen strukturierten Überblick über ungelöste Sicherheitsprobleme in Ihrer OCI-Umgebung, kategorisiert nach Risikostufe. Kritische Details wie Region, Ressourcentyp, Schweregrad und Zeitstempel für die Erkennung ermöglichen es Cybersicherheitsteams, Aktionen zu bewerten und zu priorisieren.

Nächste Schritte

Das automatisierte Reporting von Oracle Cloud Guard bietet Cybersicherheitsteams einen optimierten, proaktiven Ansatz zur Verwaltung von Cloud-Sicherheitsrisiken. Organisationen können wöchentliche Berichte über ungelöste Sicherheitsprobleme mit einer einmaligen Konfiguration erhalten, die nach Schweregrad und Risikostufe kategorisiert ist. Diese Lösung befasst sich mit der komplexen manuellen Aufgabe des Cloud-Sicherheitsmanagements und ermöglicht es Teams, sich auf die rechtzeitige Problemlösung zu konzentrieren, anstatt Probleme zu erkennen. Weitere Informationen zur Verwendung von Oracle Cloud Guard und den zugehörigen CNAPP-Funktionen erhalten Sie von Ihrem Oracle-Ansprechpartner oder unter Cloud Security Services.

Danksagungen

Autor - Aneel Kanuri (Distinguished Cloud Architect)

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie im Oracle Learning YouTube-Channel auf weitere kostenlose Lerninhalte zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Send Oracle Cloud Guard Problems through Email using Oracle Cloud Infrastructure Functions

G23224-01

December 2024

Oracle und/oder verbundene Unternehmen.