Präambel

In der sich ständig weiterentwickelnden Landschaft des Cloud Computing ist die Aufrechterhaltung robuster Sicherheit bei gleichzeitiger Gewährleistung der Compliance eine entscheidende Herausforderung für Organisationen jeder Größe. Da Unternehmen zunehmend auf Cloud-Lösungen setzen, steigt die Komplexität der Verwaltung und Sicherung von Daten über verschiedene Plattformen hinweg exponentiell an.

Amazon Bedrock bietet mit seiner leistungsstarken Grundlage an Machine-Learning- und KI-Diensten eine skalierbare und sichere Umgebung für Unternehmen zur Entwicklung und Bereitstellung intelligenter Anwendungen. Um das Potenzial dieser Innovationen voll auszuschöpfen, ist es jedoch unerlässlich, einen effizienten Ansatz für Sicherheit und Compliance umzusetzen.

Durch die Integration von Elastic mit Amazon Bedrock lässt sich die Sicherheitsüberwachung und das Compliance-Management in Ihrer Cloud-Umgebung deutlich verbessern. Diese Integration nutzt die Such-, Überwachungs- und Sicherheitsfunktionen von Elastic, um die Verwaltung und Sicherung von Anwendungen und Daten, die auf Amazon Bedrock gehostet werden, zu optimieren.

Die SIEM-Funktionen (Security Information and Event Management) von Elastic können genutzt werden, um Protokolle zu analysieren und Ereignisse zu überwachen, die von Anwendungen generiert werden, die auf Amazon Bedrock laufen. Dies ermöglicht die Erkennung potenzieller Sicherheitsbedrohungen in Echtzeit und automatisierte Reaktionsmaßnahmen zur Risikominderung.

Dieser Artikel führt Sie durch den Prozess der Einrichtung der Amazon Bedrock-Integration und der Aktivierung unserer vordefinierten Erkennungsregeln, um Ihre Sicherheitsabläufe zu optimieren. Wir werden die folgenden Schlüsselaspekte behandeln:

1. Voraussetzungen für die Elastic Amazon Bedrock Integration: Verständnis der Kernanforderungen für die Einrichtung der Elastic Amazon Bedrock Integration für Cloud-Sicherheit.
2. Einrichtung der Amazon Bedrock-Integration: Schritt-für-Schritt-Anleitung zur Einrichtung von Amazon Bedrock in Ihrer bestehenden AWS-Infrastruktur.
3. Aktivierung vordefinierter Sicherheitsregeln: So nutzen Sie vordefinierte Regeln, um Verstöße gegen Richtlinien mit hoher Wahrscheinlichkeit und andere Sicherheitsbedrohungen zu erkennen.
4. Untersuchung der Erkennung von Fehlverhaltensblöcken mit hoher Konfidenz: Ein detaillierter Blick auf eine spezifische vordefinierte Regel, die entwickelt wurde, um Fehlverhaltensblöcke mit hoher Konfidenz in Amazon Bedrocklogs zu erkennen.
5. Demonstration eines Exploit-Szenarios für Amazon Bedrock: Verwendung eines Beispiel-Python-Skripts zur Simulation von Interaktionen mit einem Amazon Bedrock-Modell zum Testen von Exploit-Szenarien, die vordefinierte Erkennungsregeln von Elastic auslösen könnten.

Voraussetzungen für die elastische Amazon Bedrock-Integration

Elastische Integration für Amazon Bedrock

Die Amazon Bedrock-Integration erfasst mit Elastic Agent Amazon Bedrock-Modellaufrufprotokolle und Laufzeitmetriken. Für eine detailliertere Beschreibung der Integration finden Sie die entsprechende Dokumentation in unserer Dokumentation.

Nachfolgend finden Sie die Liste der Voraussetzungen für eine vollständige und erfolgreiche Konfiguration von Amazon Bedrock Elastic Integration:

• AWS-Konto einrichten
• Anforderungen an eine elastische Cloud
• Terraform (optional)

AWS-Konto einrichten

• Aktives AWS-Konto: Stellen Sie sicher, dass Sie über ein aktives AWS-Konto mit den entsprechenden Berechtigungen zum Bereitstellen und Verwalten von Ressourcen auf Amazon Bedrock verfügen.
• Amazon Bedrock-Einrichtung: Stellen Sie sicher, dass Amazon Bedrock in Ihrer AWS-Umgebung korrekt konfiguriert und betriebsbereit ist. Dies umfasst die Einrichtung von KI-Modellen, Datensätzen und anderen Ressourcen, die für Ihre Anwendungen erforderlich sind. Weitere Informationen zur Einrichtung finden Sie unter Erste Schritte mit Amazon Bedrock .
• IAM-Rollen und Berechtigungen: Erstellen oder konfigurieren Sie Identity and Access Management (IAM)-Rollen mit den erforderlichen Berechtigungen, um Elastic den Zugriff auf Amazon Bedrock-Ressourcen zu ermöglichen. Diese Rollen sollten über ausreichende Berechtigungen verfügen, um Protokolle, Metriken und Traces von AWS-Diensten zu lesen. Weitere Details zu den Anforderungen finden Sie in unserer AWS-Dokumentation.

Anforderungen an eine elastische Cloud

Hinweis: Da sich die Integration noch in der Beta-Phase befindet, aktivieren Sie bitte die Option „Beta-Integrationen anzeigen“ im Abschnitt „Integrationen durchsuchen“ des Verwaltungsfensters Ihres Elastic Stack.

Terraform

Terraform ist ein Open-Source-Infrastructure-as-Code-Tool (IaC) von HashiCorp, mit dem sich Cloud- und On-Premises-Infrastruktur konsistent und wiederholbar definieren, bereitstellen und verwalten lässt.

Dies ist ein optionaler Schritt, aber es ist gut, ihn zu haben, da wir in den nächsten Abschnitten des Artikels dieses Tool verwenden, um die erforderliche AWS-Infrastruktur einzurichten. Eine detaillierte Installationsanleitung und Dokumentation finden Sie hier.

Einrichtung der Amazon Bedrock-Integration

In diesem Abschnitt des Artikels werden wir die Schritte zur Einrichtung der Amazon Bedrock-Integration mit Elastic in zwei Teilen erläutern:

1. Einrichtung der AWS-Infrastruktur mit Terraform: In diesem Abschnitt beschreiben wir die Schritte zur Einrichtung einer AWS-Infrastruktur mit Terraform. Wir erstellen einen S3-Bucket, eine EC2-Instanz mit den notwendigen IAM-Rollen und -Richtlinien für den Zugriff auf den S3-Bucket und konfigurieren Sicherheitsgruppen, um den SSH-Zugriff zu ermöglichen. Diese Konfiguration eignet sich ideal für Szenarien, in denen eine EC2-Instanz mit S3 interagieren muss, beispielsweise zur Datenverarbeitung oder -speicherung.
2. Einrichtung von Elastic Agent und Integration: In diesem Abschnitt beschreiben wir die Schritte zur Installation von Elastic Agent auf der AWS EC2-Instanz und zur Konfiguration der Amazon Bedrock-Integration.

Einrichtung der AWS-Infrastruktur mit Terraform

Der übergeordnete Konfigurationsprozess umfasst die folgenden Schritte:

1. Konfigurieren providers.tf
2. Konfigurieren variables.tf
3. Konfigurieren outputs.tf
4. Konfigurieren main.tf

Die Datei providers.tf enthält typischerweise die Konfiguration für alle Terraform-Provider, die Sie in Ihrem Projekt verwenden. In unserem Beispiel beinhaltet dies die Konfiguration für den AWS-Provider. Hier ist ein Beispielinhalt unserer providers.tf -Datei. Die in providers.tf erwähnte profile sollte im Benutzerbereich der AWS-Anmeldeinformationsdatei (~/.aws/credentials) konfiguriert werden. Siehe Konfigurations- und Anmeldeinformationsdateieinstellungen – AWS-Befehlszeilenschnittstelle, die auch im Abschnitt über Anmeldeinformationen in der AWS-Dokumentation von Elastic hervorgehoben wird.

Die Datei variables.tf enthält die Variablendefinitionen, die in Ihrer gesamten Terraform-Konfiguration verwendet werden. Für unser Szenario beinhaltet es die Definition für aws_region und resource_labels. Hier ist ein Beispielinhalt unserer variables.tf -Datei.

Die Datei outputs.tf enthält typischerweise die Ausgabedefinitionen für Ihre Terraform-Konfiguration. Diese Ausgaben können genutzt werden, um nach der Bereitstellung Ihrer Infrastruktur nützliche Informationen anzuzeigen. Hier ist ein Beispielinhalt unserer outputs.tf -Datei

Die Datei main.tf enthält typischerweise die Sammlung all dieser Ressourcen wie Datenquellen, S3-Bucket und Bucket-Richtlinie, Amazon Bedrock Model Invocation Log-Konfiguration, SQS Queue-Konfiguration, IAM-Rolle und -Richtlinien, die von der EC2-Instanz benötigt werden, auf der Elastic Agent installiert und Logs gestreamt werden, sowie die Amazon Bedrock Guardrail-Konfiguration. Hier ist ein Beispielinhalt unserer main.tf -Datei.

Sobald main.tf gemäß den Anforderungen konfiguriert ist, können wir die Terraform-Konfiguration initialisieren, planen und anwenden.

terraform init // initializes the directory and sets up state files in backend
terraform plan // command creates an execution plan
terraform apply // command applies the configuration aka execution step

Um die von Terraform zuvor erstellte Infrastruktur abzubauen, kann man den Befehl terraform destroy verwenden.

Sobald die Einrichtung der Infrastruktur abgeschlossen ist, werden die erforderlichen Ressourcenkennungen über outputs.tf. bereitgestellt. Wir können eine grundlegende Überprüfung der erstellten Infrastruktur anhand der folgenden Schritte durchführen:

1. Um den mit Terraform erstellten S3-Bucket zu überprüfen, kann man entweder den Befehl `aws cli command reference list-buckets — AWS CLI 1.34.10 Command Reference` verwenden oder die AWS-Konsole zur Überprüfung nutzen. 2. Überprüfen Sie die von Terraform erstellte SQS-Warteschlange. Dies kann entweder über den Befehl `aws cli command reference list-queues` (siehe AWS CLI 1.34.10 Command Reference) oder über die AWS-Konsole erfolgen.
2. Überprüfen Sie die in der AWS-Konsole erstellte EC2-Instanz und stellen Sie über „EC2 Instance Connect – Amazon Elastic Compute Cloud“ eine Verbindung zur ec2-Instanz her. Führen Sie anschließend aws s3 ls example-bucket-name aus, um zu prüfen, ob die Instanz Zugriff auf den erstellten S3-Bucket hat.
3. Überprüfen Sie die mit Terraform erstellten Amazon Bedrock Guardrails. Dies können Sie entweder über die Amazon Bedrock API ListGuardrails - Amazon Bedrock oder über die AWS-Konsole tun.

Einrichtung von Elastic Agent und Integrationskonfiguration

Um Elastic Agent auf der AWS EC2-Instanz zu installieren und die Amazon Bedrock-Integration zu konfigurieren, erstellen Sie eine Agentenrichtlinie anhand der geführten Schritte in Elastic Agent policies | Fleet and Elastic Agent Guide [8.15]. Melden Sie sich anschließend über Connect using EC2 Instance Connect - Amazon Elastic Compute Cloud bei der in den Infrastruktur-Setup-Schritten erstellten EC2-Instanz an und installieren Sie den Elastic Agent anhand der geführten Schritte in Install Elastic Agents | Fleet and Elastic Agent Guide [8.15]. Denken Sie bei der Agenteninstallation daran, die zu Beginn dieses Einrichtungsprozesses erstellte Agentenrichtlinie auszuwählen und je nach erstellter Instanz die entsprechende Agenteninstallationsmethode zu verwenden. Stellen Sie abschließend sicher, dass der Agent ordnungsgemäß konfiguriert ist und Daten vom Agenten empfangen werden.

Um die Amazon Bedrock-Integration in der neu erstellten Richtlinie zu konfigurieren, fügen Sie die Amazon Bedrock-Integration mithilfe der folgenden Schritte hinzu: Hinzufügen einer Elastic Agent-Integration zu einer Richtlinie. Aktivieren Sie die Beta-Integrationen, um die Amazon Bedrock-Integration wie in der Abbildung unten dargestellt zu nutzen.

Konfigurieren Sie die Integration mit AWS-Zugriffsschlüsseln, um auf das AWS-Konto zuzugreifen, in dem Amazon Bedrock konfiguriert ist. Verwenden Sie die Option „Protokolle aus dem S3-Bucket sammeln“ und geben Sie den im Einrichtungsschritt erstellten Bucket-ARN an. Bitte beachten Sie, dass Sie entweder die S3-Bucket-URL oder die SQS-Warteschlangen-URL während der Einrichtung verwenden müssen, nicht aber beide. Fügen Sie diese Integration der bestehenden Richtlinie hinzu, in der die EC2-Instanz konfiguriert ist.

Überprüfen der Amazon Bedrock-Modellaufrufprotokollaufnahmen

Sobald die Einrichtung des Elastic Agent und der Integration abgeschlossen ist, können wir eine grundlegende Überprüfung der Integration durchführen, um festzustellen, ob die Protokolle wie erwartet erfasst werden. Dazu verwenden wir den folgenden Beispiel-API-Aufruf:

aws bedrock-runtime converse \
--model-id "anthropic.claude-3-5-sonnet-20240620-v1:0" \
--messages '[{"role":"user","content":[{"text":"Hello "}]}]' \
--inference-config '{"maxTokens":2000,"stopSequences":[],"temperature":1,"topP":0.999}' \
--additional-model-request-fields '{"top_k":250}' \
--region us-east-1

Der Beispiel-API-Aufruf setzt eine funktionierende Einrichtung mit der AWS CLI voraus und es besteht Zugriff auf das grundlegende Modell Anthropic Claude Messages API - Amazon Bedrock. Wenn der Benutzer keinen Zugriff auf das Modell hat, kann er einfach über die Seite „Modellzugriff“ Zugriff auf Modelle anfordern, wie unter „Zugriff auf Amazon Bedrock Foundation-Modelle“ vorgeschlagen, oder wir können optional den API-Aufruf auf ein beliebiges vorhandenes Modell ändern, auf das der Benutzer Zugriff hat.

Bei erfolgreicher Ausführung des obigen API-Aufrufs werden die Aufrufprotokolle des Amazon Bedrock-Modells gefüllt und in Kibana logs-aws_bedrock.invocation-default sollte diese Aufrufprotokolle angezeigt werden. Wir können die folgende einfache ES|QL-Abfrage verwenden, um kürzlich erfasste Ereignisse zurückzugeben.

from logs-aws_bedrock.invocation-* | LIMIT 10

Vordefinierte Erkennungsregeln aktivieren

Um vordefinierte Erkennungsregeln zu aktivieren, melden Sie sich zunächst bei der Elastic-Instanz an und navigieren Sie im linken Navigationsbereich zu Sicherheit → Regeln → Erkennungsregeln (SIEM). Filtern Sie im Abschnitt „Tags“ nach „Datenquelle: Amazon Bedrock“.

Aktivieren Sie die verfügbaren vordefinierten Regeln. Bei vordefinierten Regeln enthält die Setup-Information eine Hilfsanleitung zum Einrichten von AWS Guardrails für Amazon Bedrock. Dies wird im Schritt „Einrichten der AWS-Infrastruktur mit Terraform“ erreicht, wenn dem Beispiel korrekt gefolgt wird und die Terraform-Datei die Amazon Bedrock Guardrail-Konfiguration enthält. Bitte beachten Sie, dass diese Konfiguration für die Generierung von Warnmeldungen durch einige Regeln unerlässlich ist – wir müssen sicherstellen, dass die Schutzmechanismen entsprechend eingerichtet werden, falls dieser Schritt bei der Einrichtung der Infrastruktur übersprungen wurde.

Erforschung von Fehlverhaltensblöcken mit hoher Sicherheit zur Erkennung

Simulieren wir ein reales Szenario, in dem ein Benutzer eine Anfrage zu einem Thema stellt, das dem Amazon Bedrock-Modell nicht zugänglich ist. Navigieren Sie in der Amazon UI Console zum Abschnitt Amazon Bedrock und verwenden Sie das linke Navigationsfeld, um zum Unterabschnitt Guardrails unter Safeguards zu navigieren. Verwenden Sie für diese Übung die im Rahmen unserer Einrichtungsanleitung erstellte Beispiel-Schutzbarriere und verwenden Sie die Testoption, um einen Modellaufruf mit den konfigurierten Schutzbarrieren durchzuführen und das verweigerte Thema abzufragen.

Wiederholen Sie die Abfrage mindestens 6 Mal, da die vordefinierte Regel so ausgelegt ist, dass sie bei mehr als 5 Blöcken mit hoher Konfidenz eine Warnung ausgibt. Wenn der Benachrichtigungsplan ausgeführt wird, wird eine Benachrichtigung angezeigt für Unusual High Confidence Misconduct Blocks Detected.

Demonstration eines Exploit-Szenarios für Amazon Bedrock

Um einen Sicherheitsfehler in Amazon Bedrock zu simulieren, benötigen wir ein Exploit-Simulationsskript, das mit Amazon Bedrock-Modellen interagiert. Das von uns bereitgestellte Exploit-Skriptbeispiel simuliert folgendes Angriffsmuster:

• Versuche mehrerer aufeinanderfolgender Anfragen zur Nutzung verweigerter Modellressourcen innerhalb von AWS Bedrock
• Erzeugt mehrere aufeinanderfolgende Validierungsausnahmefehler in Amazon Bedrock
• Der Benutzer generiert regelmäßig hohe Anzahlen an Eingabetoken, sendet zahlreiche Anfragen und erhält große Antworten, die Muster von Ressourcenerschöpfung imitieren.
• Kombiniert wiederholte, mit hoher Sicherheit durchgeführte „BLOCKIERTE“ Aktionen mit spezifischen Verstoßcodes wie „VERHALTENSVERLETZUNG“, was auf anhaltenden Missbrauch oder Versuche hinweist, die ethischen Grenzen des Modells auszuloten.

class BedrockModelSimulator:
   def __init__(self, profile_name, region_name):
       // Create a Boto3 Session Client for Ineration 
   def generate_args_invoke_model(self, model_id, user_message, tokens): 	// Generate Model Invocation parameters
       guardrail_id = <<GUARDRAIL_ID>>
       guardrail_version = <<GUARDRAIL_VERSION>>

       guardrail_config = {
           "guardrailIdentifier": guardrail_id,
           "guardrailVersion": guardrail_version,
           "trace": "enabled"
       }
       conversation = [
           {
               "role": "user",
               "content": [{"text": user_message}],
           }
       ]
       inference_config = {"maxTokens": tokens, "temperature": 0.7, "topP": 1}
       additional_model_request_fields = {}

       kwargs = {
           "modelId": model_id,
           "messages": conversation,
           "inferenceConfig": inference_config,
           "additionalModelRequestFields": additional_model_request_fields
	    "guardrailConfig" : guardrail_config
       }
       return kwargs
  
   def invoke_model(self, invocation_arguments):
       for _ in range(count):
           try:
               // Invoke Model With right invocation_arguments
           except ClientError as e:
               // Error meesage

def main():
   profile_name = <<AWS Profile>>
   region_name = 'us-east-1'
   denied_model_id = // Use a denied model   
   denied_model_user_message = // Sample Message 
   available_model_id = // Use an available model  
   validation_exception_user_message = // Sample Message 
   resource_exploit_user_message = // A very big message for resource exhuastion
   denied_topic_user_message = // Sample Message that can query denied topic configured
   simulator = BedrockModelSimulator(profile_name, region_name)
   denied_model_invocation_arguments = simulator.generate_args_invoke_model(denied_model_id, denied_model_user_message, 200)
   simulator.invoke_model(denied_model_invocation_arguments)
   validation_exception_invocation_arguments = simulator.generate_args_invoke_model(available_model_id, validation_exception_user_message, 6000)
   simulator.invoke_model(validation_exception_invocation_arguments)
   resource_exhaustion_invocation_arguments = simulator.generate_args_invoke_available_model(available_model_id, resource_exploit_user_message, 4096)
   simulator.invoke_model(resource_exhaustion_invocation_arguments)
   denied_topic_invocation_arguments = simulator.generate_args_invoke_available_model_guardrail(available_model_id, denied_topic_user_message, 4096)
   simulator.invoke_model(denied_topic_invocation_arguments)

if __name__ == "__main__":
   main()

Hinweis: Die GUARDRAIL_ID und GUARDRAIL_VERSION befinden sich in outputs.tf

Bei Ausführung in einer kontrollierten Umgebung simuliert das bereitgestellte Skript ein Exploit-Szenario, das in Elastic Security Erkennungsalarme auslösen würde. Bei der Analyse dieser Warnmeldungen mithilfe der Funktion „Elastic Attack Discovery“ erstellt das Skript Angriffsketten, die die Beziehungen zwischen verschiedenen Warnmeldungen aufzeigen und den Analysten ein klares Verständnis davon vermitteln, wie mehrere Warnmeldungen Teil eines größeren Angriffs sein könnten.

Fazit

Durch die Integration von Elastic in Amazon Bedrock können Unternehmen eine sichere und konforme Cloud-Umgebung aufrechterhalten und gleichzeitig die Vorteile von KI und maschinellem Lernen optimal nutzen. Durch den Einsatz der fortschrittlichen Sicherheits- und Überwachungstools von Elastic können Unternehmen Bedrohungen proaktiv erkennen, die Compliance-Berichterstattung automatisieren und tiefere Einblicke in ihre Cloud-Abläufe gewinnen. Immer mehr Unternehmen greifen auf intransparente Datenquellen und Technologien zurück, um die schwerwiegendsten Bedrohungen aufzudecken – unser Engagement für transparente Sicherheit zeigt sich in unseren offenen Artefakten, Integrationen und unserem Quellcode.