Note :

Ce tutoriel nécessite l'accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, voir Introduction à l' niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles propres à votre environnement en nuage.

Envoyer des problèmes Oracle Cloud Guard par courriel à l'aide d'Oracle Cloud Infrastructure Functions

Présentation

Aujourd'hui, les équipes de cybersécurité de tous les secteurs sont confrontées au défi complexe consistant à maintenir une posture de sécurité solide tout en traitant la nature dynamique des environnements infonuagiques. 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 d'équiper les organisations d'outils pour rationaliser leur gestion de la sécurité et les aider à relever ces défis de front. Oracle Cloud Guard offre de solides fonctionnalités pour aider les entreprises à simplifier la gestion de la sécurité dans le nuage, en passant de la simple identification des vulnérabilités à la répartition automatique des problèmes entre les équipes pour une résolution rapide.

Ce tutoriel décrit une solution automatisée tirant parti des services natifs d'OCI qui permet aux équipes de sécurité de recevoir et de partager des rapports détaillés sur la sécurité d'Oracle Cloud Guard directement par courriel. Cette approche réduit les interventions manuelles, facilite la surveillance continue et assure une position proactive en matière de sécurité infonuagique.

Image de l'architecture de haut niveau

Objectif

Recevez tous les problèmes ouverts Oracle Cloud Guard dans un courriel qui peut être distribué aux équipes appropriées, simplifiant ainsi la voie vers la résolution.

Préalables

Accès à une location Oracle Cloud Infrastructure (OCI).
Privilèges pour gérer Oracle Cloud Guard, le service des fonctions pour OCI, le service de transmission de messages pour OCI, le service de chambre forte pour OCI et le programmateur de ressources pour OCI.

Tâche 1 : Configurer les politiques requises et les autorisations 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.

Politique du programmateur de ressources : Permettez au programmateur d'exécuter la fonction selon un programme défini. Pour plus d'informations, voir Exemples de politique.
Politique de fonction : Accordez à la fonction l'autorisation de lire des clés secrètes à partir du service de chambre forte OCI et d'extraire les problèmes liés à Oracle Cloud Guard. Pour plus d'informations, voir Détails sur les fonctions.

Tâche 2 : Configurer le service de transmission de messages OCI

Configurez le service de transmission de messages pour OCI en créant une adresse de courriel Expéditeur approuvé, qui sera utilisée pour envoyer des rapports. Pour plus d'informations, voir Création d'un expéditeur approuvé.
Générez les données d'identification SMTP (Simple Mail Transfer Protocol) pour le compte de courriel en créant un utilisateur dédié avec des autorisations d'accès SMTP limitées.
1. Créez un utilisateur IAM OCI. Pour plus d'informations, voir Création d'un utilisateur.
2. Pour modifier des capacités d'utilisateur, voir Modification des capacités d'un utilisateur.
3. Pour créer des données d'identification SMTP, voir Création de données d'identification SMTP.

Tâche 3 : Stocker les données d'identification SMTP dans la chambre forte OCI

À l'aide du service de chambre forte OCI, stockez en toute sécurité les données d'identification SMTP. Cela ajoute une couche de sécurité supplémentaire en gardant les informations sensibles en dehors de la fonction.

Configurez une chambre forte OCI. Pour plus d'informations, voir Création d'une chambre forte.
Pour créer une clé de chiffrement principale, voir Création d'une clé de chiffrement principale.
Pour créer une clé secrète, voir Création d'une clé secrète dans une chambre forte.

Image de la configuration de la chambre forte

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

Cette fonction extrait les problèmes de sécurité non résolus détectés au cours de la dernière année. Il formate les données dans un rapport structuré basé sur des paramètres tels que le niveau de risque et le temps de détection, puis les envoie sous forme de fichier joint CSV (valeurs séparées par des virgules) par courriel. Pour plus d'informations, voir Déploiement d'une fonction.

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

Extraire les problèmes non résolus d'Oracle Cloud Guard.
Organiser et formater les problèmes en fonction de leur gravité.
Générez un rapport CSV et formatez-le.
Extrayez les données d'identification SMTP de la chambre forte.
Envoyez le courriel aux destinataires désignés avec le fichier CSV comme fichier joint.

À l'aide des fonctions sans serveur d'OCI, ce rapport peut être personnalisé pour 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 : Programmer la fonction à l'aide du programmateur de ressources OCI

La dernière tâche consiste à utiliser le programmateur de ressources OCI pour automatiser l'exécution de la fonction. Cette configuration peut être exécutée une fois par semaine ou à un intervalle personnalisé, ce qui garantit des rapports de sécurité cohérents et en temps opportun. Pour plus d'informations, voir Création de programmes.

Image de la configuration du programmateur

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

Avant de déployer la fonction, collectez les détails de configuration suivants. Ces entrées seront fournies dans le fichier de configuration de la fonction (func.yaml) ou directement dans la console OCI, selon votre méthode de déploiement.
- ID compartiment : Il s'agit de l'ID location où Oracle Cloud Guard est activé.
- Courriel de l'expéditeur : Courriel de l'expéditeur approuvé que vous avez créé dans le service de transmission de messages pour OCI.
- Courriel : Adresse de courriel à laquelle le rapport sera envoyé.
- Point d'extrémité SMTP : Pour le trouver, allez à Transmission de messages et à Configuration.
- Port SMTP : En général, 587 ou 25, comme spécifié dans la configuration du service de transmission de messages pour OCI.
- OCID de la clé secrète du nom d'utilisateur SMTP : OCID du nom d'utilisateur SMTP, stocké de manière sécurisée dans la chambre forte OCI.
- OCID de la clé secrète du mot de passe SMTP : OCID du mot de passe SMTP, stocké de manière sécurisée dans la chambre forte OCI.
- Niveau d'accès au service de protection d'infrastructure en nuage : 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 un aperçu structuré des problèmes de sécurité non résolus dans votre environnement OCI, classés par niveau de risque. Les détails critiques 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.

Étapes suivantes

Les rapports automatisés d'Oracle Cloud Guard offrent aux équipes de cybersécurité une approche rationalisée et proactive de la gestion des risques de sécurité infonuagiques. Les organisations peuvent recevoir des rapports hebdomadaires sur les problèmes de sécurité non résolus avec une configuration ponctuelle, classée par gravité et niveau de risque. Cette solution traite les tâches manuelles complexes de gestion de la sécurité en nuage, 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 capacités CNAPP, communiquez avec votre représentant Oracle ou consultez Services de sécurité en nuage.

Confirmation

Auteur - Aneel Kanuri (architecte en nuage distinct)

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.

Titre et Copyright

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

G23226-01

December 2024

Oracle et/ou ses sociétés affiliées.