Remarques :

Ce tutoriel nécessite un accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, reportez-vous à Introduction au niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeurs pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. Lorsque vous terminez votre atelier, remplacez ces valeurs par celles propres à votre environnement cloud.

Envoi de problèmes Oracle Cloud Guard par courriel à l'aide d'Oracle Cloud Infrastructure Functions

Introduction

Aujourd'hui, les équipes de cybersécurité de tous les secteurs sont confrontées au défi complexe de maintenir une posture de sécurité solide tout en faisant face à la nature dynamique des environnements cloud. Avec d'innombrables ressources, configurations et menaces en constante évolution, le suivi et la résolution rapide des problèmes sont cruciaux. Chez Oracle, nous reconnaissons l'importance de doter les entreprises d'outils pour rationaliser leur gestion de la sécurité, ce qui les aide à relever ces défis de front. Oracle Cloud Guard offre des fonctionnalités robustes pour aider les entreprises à simplifier la gestion de la sécurité dans le cloud, passant de la simple identification des vulnérabilités à la distribution automatique des problèmes entre les équipes pour une résolution rapide.

Ce tutoriel présente une solution automatisée exploitant les services natifs d'OCI qui permet aux équipes de sécurité de recevoir et de partager des rapports de sécurité Oracle Cloud Guard détaillés directement par e-mail. Cette approche réduit les interventions manuelles, facilite la surveillance continue et garantit une position proactive dans la sécurité du cloud.

Image de l'architecture de haut niveau

Objectif

Recevez tous les problèmes non résolus d'Oracle Cloud Guard dans un courriel qui peut être distribué aux équipes appropriées, ce qui simplifie le processus de résolution.

Prérequis

Accès à une location Oracle Cloud Infrastructure (OCI).
Privilèges permettant de gérer Oracle Cloud Guard, OCI Functions, le service OCI Email Delivery, OCI Vault et OCI Resource Scheduler.

Tâche 1 : configuration des stratégies requises et des droits d'accès Oracle Cloud Infrastructure Identity and Access Management (OCI IAM)

Chaque composant de cette solution doit avoir accès aux ressources OCI avec lesquelles il interagit.

Stratégie de planificateur de ressources : Autorisez le planificateur à exécuter la fonction selon un planning défini. Pour plus d'informations, reportez-vous à la section Example Policies.
Stratégie de fonction : autorisez la fonction à lire les clés secrètes à partir d'OCI Vault et à extraire les problèmes Oracle Cloud Guard. Pour plus d'informations, reportez-vous à Détails du service Functions.

Tâche 2 : configuration du service de transmission de courriel OCI

Configurez le service OCI Email Delivery en créant une adresse électronique d'expéditeur approuvé, qui sera utilisée pour envoyer des rapports. Pour plus d'informations, reportez-vous à Création d'un expéditeur approuvé.
Générez des informations d'identification SMTP (Simple Mail Transfer Protocol) pour le compte de messagerie en créant un utilisateur dédié avec des autorisations d'accès SMTP limitées.
1. Créez un utilisateur OCI IAM. Pour plus d'informations, reportez-vous à Création d'un utilisateur.
2. Pour modifier les fonctionnalités utilisateur, reportez-vous à Modification des fonctionnalités d'un utilisateur.
3. Pour créer les informations d'identification SMTP, reportez-vous à Création des informations d'identification SMTP.

Tâche 3 : stockage des informations d'identification SMTP dans OCI Vault

A l'aide d'OCI Vault, stockez en toute sécurité les informations d'identification SMTP. Cela ajoute une couche de sécurité supplémentaire en conservant les informations sensibles en dehors de la fonction.

Configurez un coffre OCI. Pour plus d'informations, reportez-vous à Création d'un coffre.
Pour créer une clé de cryptage maître, reportez-vous à Création d'une clé de cryptage maître.
Pour créer une clé secrète, reportez-vous à Création d'une clé secrète dans un coffre.

Image de la configuration du coffre

Tâche 4 : développer et déployer la fonction

Cette fonction extrait les problèmes d'état de sécurité non résolus détectés au cours de l'année écoulée. Il formate les données dans un rapport structuré en fonction de paramètres tels que le niveau de risque et le temps de détection, puis l'envoie sous forme de pièce jointe de valeurs séparées par des virgules (CSV) par e-mail. Pour plus d'informations, reportez-vous à Déploiement d'une fonction.

Voici un aperçu des étapes de la fonction principale :

Récupérez les problèmes non résolus à partir d'Oracle Cloud Guard.
Organisez et formatez les problèmes en fonction de leur gravité.
Générez un rapport CSV et formatez-le.
Extrayez les informations d'identification SMTP du coffre.
Envoyer le courriel aux destinataires désignés avec un fichier CSV en pièce jointe.

Grâce aux fonctionnalités sans serveur d'OCI, ce rapport peut être personnalisé afin de fournir une clarté maximale sur les domaines de sécurité critiques pour les équipes de cybersécurité.

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
```

Image de la configuration de la fonction

Tâche 5 : programmation de la fonction avec OCI Resource Scheduler

La dernière tâche consiste à utiliser OCI Resource Scheduler pour automatiser l'exécution de la fonction. Cette configuration peut être exécutée chaque semaine ou à un intervalle personnalisé, garantissant ainsi un reporting de sécurité cohérent et opportun. Pour plus d'informations, reportez-vous à Création de programmations.

Image de la configuration du planificateur

Pour exécuter la fonction, entrez les informations requises suivantes.

Avant de déployer la fonction, rassemblez les détails de configuration suivants. Ces entrées seront fournies dans le fichier de configuration de fonction (func.yaml) ou directement dans la console OCI, selon votre méthode de déploiement.
- ID de compartiment : ID de location dans lequel Oracle Cloud Guard est activé.
- A partir du courriel : courriel de l'expéditeur approuvé que vous avez créé dans le service OCI Email Delivery.
- A envoyer par courriel : adresse électronique à laquelle le rapport sera envoyé.
- Adresse SMTP : pour la trouver, accédez à Email Delivery et à Configuration.
- Port SMTP : généralement 587 ou 25, comme indiqué dans la configuration du service OCI Email Delivery.
- OCID de clé secrète de nom utilisateur SMTP : OCID du nom utilisateur SMTP, stocké en toute sécurité dans OCI Vault.
- OCID de clé secrète de mot de passe SMTP : OCID du mot de passe SMTP, stocké en toute sécurité dans OCI Vault.
- Niveau d'accès Cloud Guard : définit le niveau d'accès des ressources (ACCESSIBLE ou RESTRICTED). La valeur par défaut est ACCESSIBLE.
Nous obtiendrons un exemple de sortie qui est un rapport Oracle Cloud Guard exploitable.

Ce rapport Oracle Cloud Guard fournit une présentation structurée des problèmes de sécurité non résolus dans votre environnement OCI, classés par niveau de risque. Des détails essentiels tels que la région, le type de ressource, la gravité et les horodatages de détection permettent aux équipes de cybersécurité d'évaluer et de hiérarchiser les actions.

Etapes suivantes

Le reporting automatisé d'Oracle Cloud Guard offre aux équipes de cybersécurité une approche rationalisée et proactive de la gestion des risques de sécurité dans le cloud. Les organisations peuvent recevoir des rapports hebdomadaires sur les problèmes de sécurité non résolus avec une configuration unique, classés par niveau de gravité et de risque. Cette solution répond à la tâche manuelle complexe de la gestion de la sécurité dans le cloud, permettant aux équipes de se concentrer sur la résolution des problèmes en temps opportun plutôt que sur le suivi des problèmes. Pour plus d'informations sur l'utilisation d'Oracle Cloud Guard et de ses fonctionnalités CNAPP, contactez votre représentant Oracle ou consultez les services de sécurité cloud.

Remerciements

Auteur - Aneel Kanuri (architecte cloud distingué)

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à d'autres contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation produit, consultez le site Oracle Help Center.

Informations relatives au titre et au copyright

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

G23227-01

December 2024

Oracle et/ou ses affiliés.