AWS Lambda-Sicherheit: Automatisierte ECR-Schwachstellenüberprüfungen

In der dynamischen Welt des serverlosen Computings ist die Sicherung Ihrer AWS Lambda-Funktion entscheidend. Ein oft vernachlässigter Bereich ist jedoch die Sicherheit von containerisierten Anwendungen in Amazon Elastic Container Registry (ECR). In diesem Blog wird eine leistungsstarke Lösung für die Verwendung von AWS Lambda, EventBridge und Simple Notification Service (SNS) zur Automatisierung von Schwachstellenprüfungen für ECR-Repositories vorgestellt. 

Am Ende werden Sie ein tieferes Verständnis dafür haben, wie Sie Ihre serverlose Architektur gegen potenzielle Risiken absichern können.

Wir führen Sie durch die drei wichtigsten Komponenten, um Ihnen zu zeigen, wie diese Teile zusammenpassen. 

1. AWS Lambda: Automatisierte Schwachstellenüberprüfungen

Schauen wir uns zunächst die Lambda-Funktion an und sehen wir uns an, welche Rolle sie in unserer Sicherheitslösung spielt.

In diesem Abschnitt werden wir das Herzstück unserer Sicherheitseinrichtung erkunden - AWS Lambda. Dieses Tool hilft bei der automatischen Prüfung auf Schwachstellen in Docker-Images, die in Amazon Elastic Container Registry (ECR) gespeichert sind. Wir werden die wesentlichen Teile und die Funktionsweise unserer Lambda-Funktion mit dem erforderlichen, in Python geschriebenen Code aufschlüsseln, um Ihnen ein klares Verständnis ihrer entscheidenden Rolle bei der Verbesserung Ihrer containerisierten Sicherheit zu vermitteln.

"Lambda ECR prüft, leicht und luftig, sucht Schwachstellen mit der größten Leichtigkeit!" 😏

Viel Spaß mit dem Inhalt 🙂 

 Schauen wir uns die wichtigsten Komponenten und die Logik unserer Lambda-Funktion an.

Zu Beginn müssen wir eine Lambda-Funktion in der AWS Management Console erstellen. Dann geben wir die erforderliche IAM-Rolle mit den Berechtigungen des Lambdas an, um mit ECR, S3 und SNS zu interagieren. Der S3-Bucket dient zum Speichern der Protokolle der gemeldeten Schwachstellen.

Das Diagramm befindet sich am Ende des Themas und enthält eine kurze Zusammenfassung.

Wenn Sie eine neue AWS Lambda-Funktion erstellen, haben Sie die Möglichkeit, entweder eine vorhandene IAM-Rolle auszuwählen oder eine neue Rolle für die Funktion zu erstellen. Wenn Sie sich für das Erstellen einer neuen Rolle entscheiden, erstellt AWS Lambda automatisch eine IAM-Rolle mit den erforderlichen Berechtigungen für Ihre Funktion. 

Wir werden den Lambda mit einer neuen IAM-Rolle erstellen und die Rollenberechtigungen später aktualisieren.

• Beginnen Sie mit der Erstellung des Lambdas:

Fügen Sie Ihre Informationen an den richtigen Stellen ein.

import boto3
from datetime import datetime
today = datetime.now()
import os

ECR_NAME = os.environ['ECR_NAME']
SNS_ARN = os.environ['SNS_ARN']
S3_BUCKET = os.environ['S3_BUCKET']

def get_latest_ecr_image(repository_name):
    """
    Get details about the latest pushed image in the specified ECR repository.
    """
    ecr_client = boto3.client('ecr')
    image_details = ecr_client.describe_images(repositoryName=repository_name, filter={'tagStatus': 'TAGGED'})['imageDetails']

    # Sort images based on push timestamp in descending order
    sorted_images = sorted(image_details, key=lambda x: x['imagePushedAt'], reverse=True)

    return sorted_images[0] if sorted_images else None

def send_sns_alert(topic_arn, message):
    """
    Send an alert message to the specified SNS topic.
    """
    sns_client = boto3.client('sns')
    sns_client.publish(TopicArn=topic_arn, Message=message, Subject="Vulnerability Alert from un1te-wl-dev")

def lambda_handler(event, context):
    # Fetch details about the latest pushed image in the repository
    
    ECRS = ECR_NAME.split(",")
    for ecr in ECRS:
        latest_image_detail = get_latest_ecr_image(ecr)
        
        # Check if there is a latest pushed image in the repository
        if latest_image_detail:
            image_id = latest_image_detail['imageTags'][0]  # Use the first tag as the image identifier
    
            # Check if 'imageScanFindings' key is present in the image details
            if 'imageScanFindingsSummary' in latest_image_detail:
                # Get the actual vulnerability findings
                scan_findings = latest_image_detail['imageScanFindingsSummary']['findingSeverityCounts']
                print (scan_findings)
                #Severity = 'High'
                # Check if there are 'High' or 'Critical' vulnerabilities
                
                if ( 'CRITICAL' in scan_findings ):
                    critical = scan_findings['CRITICAL']
                else:
                    critical = 0
                if ( 'HIGH' in scan_findings ):
                    high = scan_findings['HIGH']
                else:
                    high = 0
                    
                if (critical + high >= 0): 
                    # Report vulnerabilities to S3
                    s3_client = boto3.client('s3')
                    report_content = f"Vulnerabilities found in Latest Pushed Image ID: {image_id}\n"
                    report_content += str(scan_findings)
                    key = f'vulnerability_report_'+ecr+'_'+today.strftime("%Y%m%d_%H%M")+'.txt'
                    s3_client.put_object(Bucket=S3_BUCKET, Key=key, Body=report_content)
    
                    # Send an alert via SNS
                    alert_message = f"Vulnerabilities found in ECR {ecr} Latest Pushed Image ID: {image_id}"
                    send_sns_alert(SNS_ARN, alert_message)
                else:
                    print ("-- ok --")
    
    return "Vulnerability check completed."

Mit dieser Lambda-Funktion werden automatisierte Schwachstellenprüfungen zu einem integralen Bestandteil der Sicherheitsstrategie für Ihr ECR-Repository.

1.1. Logik der Lambda-Funktionen

Lassen Sie uns die Logik aufschlüsseln:

• Die Lambda-Funktion holt Details über alle Bilder im angegebenen ECR-Repository.

Er durchläuft jedes Bild und sucht nach Schwachstellen auf der Grundlage von "Schweregrad"-K riterien.

Wenn Schwachstellen gefunden werden (mit dem Schweregrad "Hoch" oder "Kritisch"), erstellt die Funktion einen Bericht mit den im Bild gefundenen Schwachstellen.

• Der Bericht wird dann in einen S3-Bucket mit dem Namen my-bucket-name hochgeladen.
• Warnmeldungen über SNS:

Es sendet eine sofortige Warnmeldung an ein SNS-Thema mit Informationen über die Schwachstellen, einschließlich der Bild-ID und des Schweregrads.

Das SNS-Thema hat Abonnenten, zu denen auch E-Mail-Adressen gehören können, die Benachrichtigungen über die Schwachstellen erhalten.

2. IAM-Rolle für unseren Lambda:

• Gehen Sie zu AWS Lambda
• Wählen Sie "Konfiguration".
• Wählen Sie in der linken Leiste "Berechtigungen".
• Suchen Sie die "Ausführungsrolle" (überprüfen Sie den Namen) und klicken Sie sie an.

Oder navigieren Sie zu IAM und wählen Sie die Lambda-Rolle (prüfen Sie, ob das Lambda bereits erstellt wurde) und erweitern Sie die Berechtigungen. Wählen Sie Bearbeiten und fügen Sie den Inhalt unten ein:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "arn:aws:logs:region:MY-ACCOUNT-ID:*"
        },
        {
            "Effect": "Allow",
            "Action": "events:*",
            "Resource": "arn:aws:lambda:region:MY-ACCOUNT-ID:function:my-lambda-name"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ecr:DescribeRepositories",
                "ecr:StartImageScan",
                "ecr:DescribeImageScanFindings",
                "ecr:ListImages",
                "ecr:DescribeImages"
            ],
            "Resource": [
                "arn:aws:ecr:region:MY-ACCOUNT-ID:repository/my-repo-name"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "sns:Publish"
            ],
            "Resource": "arn:aws:sns:region:MY-ACCOUNT-ID:my-sns-topic-name"
        },
        {
            "Effect": "Allow",
            "Action": "s3:*",
            "Resource": [
                "arn:aws:s3:::my-bucket-name/*",
                "arn:aws:s3:::my-bucket-name"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:region:MY-ACCOUNT-ID:log-group:/aws/lambda/my-lambda-name:*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction"
            ],
            "Resource": [
                "arn:aws:lambda:region:MY-ACCOUNT-ID:function:my-lambda-name:*",
                "arn:aws:lambda:"arn:aws:lambda:region:MY-ACCOUNT-ID:function:my-lambda-name"
            ]
        }
    ]
}

Schlüsseln wir die Logik der Richtlinie auf und erläutern wir, wofür die Berechtigung verwendet wird:
1. logs:CreateLogGroup
Der Zweck dieser Berechtigung besteht darin, der Lambda-Funktion zu erlauben, Protokollgruppen in AWS CloudWatch Logs zu erstellen. Protokollgruppen werden verwendet, um die von der Lambda-Funktion erzeugten Protokolle zu organisieren und zu speichern.
2. events:*
Sie erteilt die Berechtigung für EventBridge-Operationen in Bezug auf die angegebene Lambda-Funktion. Dies ist wichtig für die Verwaltung von Ereignissen und Auslösern, die mit der Lambda-Funktion verbunden sind.
3. ECR-Berechtigungen:
Diese Berechtigungen ermöglichen es der Lambda-Funktion, mit dem angegebenen Amazon ECR-Repository zu interagieren.
4. SNS-Berechtigungen:
Ihr Zweck ist es, die Lambda-Funktion in die Lage zu versetzen, Nachrichten an das angegebene SNS-Thema zu veröffentlichen. Dies ist für das Senden von Alarmen oder Benachrichtigungen entscheidend.
5. S3-Berechtigungen:
Gewährt vollen Zugriff auf den angegebenen S3-Bucket und dessen Inhalt. Dies ermöglicht der Lambda-Funktion das Speichern, Abrufen und Verwalten von Objekten im S3-Bucket.
6. CloudWatch Logs Permissions:
Diese Berechtigungen ermöglichen es der Lambda-Funktion, Log-Streams zu erstellen und Log-Ereignisse in die angegebene CloudWatch Logs Log-Gruppe zu stellen.
7. Lambda Permissions:
Berechtigt die Lambda-Funktion, sich selbst und andere Lambda-Funktionen aufzurufen. Dies ist für die ereignisgesteuerte Ausführung und das Aufrufen anderer Funktionen erforderlich.

Mit diesen Berechtigungen wird sichergestellt, dass die Lambda-Funktion über die erforderlichen Zugriffsrechte verfügt, um die ihr zugewiesenen Aufgaben auszuführen, die Aspekte wie Protokollierung, Ereignisbehandlung, ECR-Interaktionen, Alarmierung, S3-Zugriff und Lambda-Funktionsaufruf umfassen.

Gehen Sie neben der Registerkarte "Berechtigungen" auf die Registerkarte "Vertrauensbeziehungen" der IAM-Rolle und fügen Sie den Inhalt ein:
Die Vertrauensbeziehungen werden verwendet, um festzulegen, welche Dienste die Rolle übernehmen dürfen:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": [
                    "events.amazonaws.com",
                    "lambda.amazonaws.com"
                ]
            },
            "Action": "sts:AssumeRole"
        },
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "scheduler.amazonaws.com"
            },
            "Action": "sts:AssumeRole",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "MY-ACCOUNT-ID"
                }
            }
        }
    ]
}

Zusammenfassung: Wir haben die Lambda-Funktion und die IAM-Rolle mit der Vertrauensbeziehung erstellt, die der Lambda-Funktion zugeordnet ist.

3. S3-Bucket zum Speichern von Protokollen

Fahren wir mit der Erstellung des S3-Buckets mit den erforderlichen Berechtigungen fort, an das der Lambda die Protokolle senden wird.

• Navigieren Sie zu S3
• Wählen Sie "Eimer erstellen".
• Fügen Sie den folgenden Berechtigungsinhalt in die Bucket-Policy ein

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "lambda.amazonaws.com"
            },
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::my-bucket-name/*"
        }
    ]
}

Die Bucket-Richtlinie erteilt unserer AWS Lambda-Funktion die erforderlichen Berechtigungen, die es ihr ermöglichen, Objekte in den angegebenen S3-Bucket hochzuladen. 

Der nächste Schritt ist die Erstellung eines Zeitplans über EventBridge, damit der Lambda ausgelöst werden kann, wann immer wir wollen.

4. EventBridge für zeitgesteuerte Automatisierung

EventBridge spielt eine zentrale Rolle bei der Orchestrierung der automatischen Schwachstellenprüfungen. Geplante Ereignisse sorgen für regelmäßige Sicherheitsüberprüfungen. Hier erfahren Sie, wie Sie einen Zeitplan in der AWS Management Console konfigurieren können:

• Navigieren Sie zur EventBridge-Konsole.
• Erstellen Sie einen neuen Zeitplan.
• Wählen Sie die Ereignisquelle (Zeitplan) und konfigurieren Sie den Zeitplanausdruck (z. B. cron(0 8 ? * MON *)).

In diesem Fall wird das Lambda jeden Montag um 8 Uhr ausgelöst.

Legen Sie als Ziel die auf Seite 1 erstellte Lambda-Funktion sowie die Ausführungsrolle des Lambdas fest.

Als letzten Schritt werden wir ein SNS-Thema für die Alarmierung erstellen.

5. SNS für sofortige Alarmierung

Der Simple Notification Service (SNS) dient der Alarmierung oder Benachrichtigung relevanter Akteure oder Systeme. In unserem Fall wird er uns benachrichtigen, wenn in unseren (ECR-)Repositories hohe oder kritische Schwachstellen entdeckt werden. Schauen wir uns seine Rolle an: Das SNS-Thema ist so konfiguriert, dass es die Warnmeldungen empfängt und als Kommunikationskanal dient. Anschließend werden die Warnungen von der Lambda-Funktion unter Verwendung des AWS SDK (Boto3 im Falle von Python) veröffentlicht, um eine Nachricht an das konfigurierte SNS-Thema zu senden. (Ein Beispiel für die E-Mail finden Sie unten - Seite 9)

Die Abonnenten des SNS-Themas, bei denen es sich um E-Mail-Adressen, andere AWS Lambda-Funktionen oder andere Systeme handeln kann, erhalten die Benachrichtigungen.

SNS gewährleistet die rechtzeitige und skalierbare Zustellung von Nachrichten an alle abonnierten Endpunkte und eignet sich daher für die sofortige Alarmierung.

Lassen Sie uns nun mit der Erstellung des SNS-Themas fortfahren.

• Erstellen Sie ein "Standard"-Thema.
• Zugangspolitik

Stellen Sie sicher, dass die Zugriffsrichtlinie über die folgenden Berechtigungen verfügt:

{
  "Version": "2008-10-17",
  "Id": "__default_policy_ID",
  "Statement": [
    {
      "Sid": "__default_statement_ID",
      "Effect": "Allow",
      "Principal": {
        "AWS": "*"
      },
      "Action": [
        "SNS:Publish",
        "SNS:RemovePermission",
        "SNS:SetTopicAttributes",
        "SNS:DeleteTopic",
        "SNS:ListSubscriptionsByTopic",
        "SNS:GetTopicAttributes",
        "SNS:AddPermission",
        "SNS:Subscribe"
      ],
      "Resource": "arn:aws:sns:region:MY-ACCOUNT-ID:my-sns-topic-name",
      "Condition": {
        "StringEquals": {
          "AWS:SourceOwner": "MY-ACCOUNT-ID"
        }
      }
    }
  ]
}

• Abonnement erstellen:

• Themen-ARN - das von Ihnen erstellte Thema 
• Protokoll: E-Mail (fügen Sie Ihre E-Mail-Adresse hinzu, damit Sie die E-Mail-Benachrichtigung erhalten können)

Dann erhalten Sie eine E-Mail und wählen Sie abonnieren.

Beispiel für die E-Mail, die Sie erhalten, wenn hohe oder kritische Schwachstellen gefunden werden:

Thema: Warnung vor Sicherheitslücken

"Sicherheitslücken gefunden in ECR my-repo-name Image ID: XXX - Schweregrad: Hoch

Wenn Sie keine Benachrichtigungen zu diesem Thema mehr erhalten möchten, klicken Sie bitte auf den nachstehenden Link oder besuchen Sie ihn, um sich abzumelden:

Bitte antworten Sie nicht direkt auf diese E-Mail. Wenn Sie Fragen oder Kommentare zu dieser E-Mail haben, kontaktieren Sie uns bitte unter https://aws.amazon.com/support"

Lassen Sie uns nun die Komponenten zu einer kohärenten Lösung zusammenführen. Die Lambda-Funktion wird durch geplante Ereignisse über EventBridge ausgelöst. Wenn Schwachstellen entdeckt werden, werden sofort Warnmeldungen über SNS gesendet und die Protokolle an S3 gesendet.

Geplanter Ereignisauslöser:

EventBridge wird mit einem Zeitplanausdruck (z. B. cron) konfiguriert, der die Lambda-Funktion in bestimmten Intervallen auslöst.

Lambda-Ausführung:

Die Lambda-Funktion, die für die Schwachstellenbewertung zuständig ist, wird von EventBridge auf der Grundlage des Zeitplans aufgerufen.

Erkennung von Schwachstellen:

Die Lambda-Funktion durchsucht die ECR-Repositories nach Schwachstellen. Wenn hohe oder kritische Schwachstellen entdeckt werden, wird mit dem nächsten Schritt fortgefahren.

SNS-Warnmeldungen:

Eine sofortige Warnung wird über SNS an abonnierte Endpunkte (z. B. E-Mail-Adressen) gesendet, um die Beteiligten über die entdeckten Schwachstellen zu informieren.

S3-Speicherprotokolle:

Die Protokolle werden unter dem Namen "vulnerability_report_imageID.txt" (der Name ist in der Lambda-Funktion beschrieben, Sie können ihn nach Ihren Bedürfnissen ändern) in den S3-Bucket geschrieben.

Zusammenfassend lässt sich sagen, dass die Integration von AWS Lambda, EventBridge und SNS eine robuste und sichere Lösung für die Automatisierung von Schwachstellenprüfungen in ECR-Repositories schafft. Dieser Ansatz gewährleistet zeitnahe Bewertungen, sofortige Warnungen und beachtet die Best Practices für serverlose Sicherheit. Darüber hinaus kann die effiziente Nutzung der serverlosen Architektur, wie AWS Lambda, zu potenziellen Kosteneinsparungen beitragen, insbesondere wenn das Pay-as-you-go-Modell genutzt wird. Wie gezeigt, erhöht die Implementierung von Lambda-Funktionen für ECR-Schwachstellenprüfungen nicht nur die Sicherheit, sondern bietet auch eine wirtschaftliche und skalierbare Lösung für Unternehmen. Durch die Einführung dieser serverlosen Strategie können Unternehmen sowohl betriebliche Effizienz als auch Kosteneffizienz bei der Verwaltung der Containersicherheit innerhalb ihrer AWS-Umgebung erreichen.

Wir hoffen, dass das Thema für Sie hilfreich war und Sie Ihren Lambda erfolgreich integriert haben. Für Fragen und Ratschläge stehen wir Ihnen weiterhin gerne zur Verfügung. Wir wünschen Ihnen weiterhin viel Erfolg bei Ihren Serverless-Bestrebungen. Bis zu unserer nächsten Interaktion, viel Spaß beim Coding!

Entdecken Sie die Dienstleistungen von ITGix und erfahren Sie mehr über unser Know-how.