Nutzung von Terraform für verbesserte Asset-Sicherheit mit Mondoo - Teil 1: Ressourcen

In einer Zeit, in der das Management der Informationssicherheit wichtiger denn je ist, suchen Unternehmen nach innovativen Lösungen, um ihre digitalen Ressourcen effektiv zu schützen. Hier kommt Mondoo ins Spiel, eine dynamische Plattform, die die Sicherheit und Compliance in verschiedenen Infrastrukturen verbessert. Durch die Integration mit Terraform nutzt Mondoo die Leistungsfähigkeit von Infrastructure as Code, um die Bereitstellung von sicheren und konformen Umgebungen zu automatisieren und zu optimieren. Unsere Partnerschaft mit Mondoo hat nicht nur unsere und Mondoos Fähigkeiten erweitert, sondern auch ein robusteres Framework für die Verwaltung der Infrastruktursicherheit geschaffen, das es Unternehmen erleichtert, sich an die sich schnell verändernden Sicherheitslandschaften anzupassen. Gemeinsam setzen Mondoo und Terraform neue Maßstäbe für das proaktive Management von Informationssicherheit. Diese Blog-Serie wird sich auf die neuesten Updates konzentrieren, die sich aus unserer Partnerschaft ergaben. In diesem Blogpost geht es um alle Entwicklungen der Terraform Provider Ressourcen.

Ein paar Worte zu Mondoo

Mondoo ist eine umfassende Sicherheits- und Compliance-Plattform, die verschiedene Infrastrukturkomponenten wie Cloud-Anbieter, SaaS-Plattformen und sogar Workstations integrieren kann. Sie bietet kontinuierliche Sicherheitsbewertungen und Compliance-Prüfungen und trägt dazu bei, dass IT-Infrastrukturen sicher sind und Best Practices sowie Compliance-Richtlinien eingehalten werden. Mondoo ist vor allem für seine Policy-as-Code-Funktionen bekannt, die eine automatisierte Durchsetzung der Sicherheit in allen Entwicklungs- und Betriebsprozessen ermöglichen.

Eine ausführlichere Erklärung und Einblicke in die Funktionsweise von Mondoo kann in unserem Blog gefunden werden.

Im Rahmen unserer Partnerschaft konnten wir aktiv an der Weiterentwicklung von Mondoo, insbesondere des Mondoo Terraform Providers, mitwirken, um eine größere Vielfalt an Terraform-Ressourcen für die einfache und automatisierte Integration von IT-Assets anbieten zu können.

Entdecken von Mondoos Integrationstypen

Ab Juni 2024 bietet der Mondoo Terraform Provider eine Vielzahl von Ressourcen- und Integrationstypen für die Asset-Integration sowie vier wertvolle Datenquellen an und wird seine Möglichkeiten weiter ausbauen. Zu den Ressourcen gehören Verwaltungsoptionen für Policies, Assets und Integrationen, die es uns ermöglichen, umfassende Sicherheits- und Compliance-Kontrollen nahtlos in die von Terraform verwaltete Infrastruktur zu implementieren.

Integration der Google Cloud Platform

Die Mondoo GCP-Integration ermöglicht das kontinuierliche Scannen von Google Cloud Platform (GCP)-Ressourcen, um Schwachstellen und Fehlkonfigurationen zu identifizieren. Diese Integration wird eingerichtet, indem die Terraform-Datei so konfiguriert wird, dass sie die GCP-Integrationsressourcen von Mondoo enthält. Dazu müssen die GCP-Anmeldedaten und der Umfang der zu überwachenden Ressourcen angegeben werden.

Es ist sicherzustellen, dass die notwendigen Voraussetzungen für eine erfolgreiche Integration geschaffen werden, wie z.B. die Konfiguration von GCP IAM-Rollen und Berechtigungen, um Mondoo den Zugriff für das Scannen zu ermöglichen. Detaillierte Einrichtungsanweisungen und Anforderungen können in der Mondoo-Dokumentation gefunden werden.

Google Cloud Platform Ressource

Integration der Oracle-Cloud-Infrastruktur

Die Mondoo OCI (Oracle Cloud Infrastructure)-Integration ermöglicht das kontinuierliche Scannen von OCI-Ressourcen, um Sicherheitsschwachstellen und Fehlkonfigurationen zu erkennen. Um diese Integration einzurichten, muss die Terraform-Datei mit den notwendigen Details wie OCI-Anmeldeinformationen und den spezifischen Ressourcen oder Compartments, die überwacht werden sollen, konfiguriert werden.

Für eine erfolgreiche Integration von Mondoo in die Oracle Cloud Infrastructure (OCI) muss sichergestellt sein, dass die erforderlichen OCI-Richtlinien und -Rollen konfiguriert sind. Diese Vorbereitung ermöglicht es Mondoo, umfassende Sicherheitsscans durchzuführen. Detaillierte Anweisungen zur Konfiguration des OCI-Zugangs für Mondoo sind in der Mondoo-Dokumentation zu finden.

Oracle Cloud Infrastructure Ressource

Zusammen mit dem Mondoo Team haben wir den Mondoo Terraform Provider seit April 2024 erheblich erweitert und bieten nun eine größere Auswahl an Integrationstypen und Ressourcen an, um die Sicherheit und Compliance über verschiedene Plattformen hinweg mit einem automatisierten Prozess zu stärken. Erkunden wir die Integrationstypen gemeinsam!

Integration von Microsoft Azure

Die Integration von Terraform in Mondoo wurde mit Version 0.5 um die Microsoft Azure Integration erweitert. Diese ermöglicht es dem Mondoo Terraform Provider, Microsoft Azure-Abonnements und deren Ressourcen kontinuierlich zu scannen und Fehlkonfigurationen und Schwachstellen zu identifizieren. Die Integration wurde entwickelt, um die Sicherheit und Compliance zu verbessern, indem Einblicke in die Azure-Umgebung direkt von der Mondoo-Plattform aus gewährt werden.

Dieser Integrationstyp erleichtert nahtlose Sicherheitsprüfungen über Azure-Ressourcen hinweg und stellt sicher, dass diese mit den Sicherheitsrichtlinien und Compliance-Anforderungen des Unternehmens übereinstimmen. Benutzer können die Azure-Integration einfach über die Terraform-Konfiguration einrichten, indem sie die erforderlichen Parameter wie die Azure-Abonnement-ID und die Anmeldedaten angeben.

Wir müssen sicherstellen, dass wir die Voraussetzungen für die Integration von Mondoo mit Microsoft Azure erfüllen. Dazu gehört die Konfiguration von Azure, damit Mondoo die Abonnements auf Sicherheits- und Compliance-Probleme überprüfen kann. Zu den wesentlichen Schritten gehören die Einrichtung der entsprechenden Azure Active Directory (AD)-Berechtigungen, die Erstellung einer benutzerdefinierten Rolle mit den erforderlichen Zugriffsrechten und die Erstellung eines Service Principal für die Authentifizierung.

Microsoft Azure Ressource

Integration von Domains

Ein weiteres spannendes Feature des Mondoo Terraform Providers ab Version 0.5 ist die Integration mit Domains oder Websites. Dieser Integrationstyp ermöglicht das Scannen von Domainkonfigurationen, um Sicherheitsfehlkonfigurationen und Schwachstellen zu identifizieren, was eine wesentliche Sicherheitsebene für weborientierte Assets darstellt.

Bei der Domain/Website-Integration über Mondoo können die Benutzer die zu überwachenden Domainnamen angeben. Einmal konfiguriert, kann Mondoo die Sicherheitslage dieser Domains bewerten und sie auf Probleme wie SSL/TLS-Schwächen, falsch konfigurierte DNS-Einträge und andere gängige Web-Schwachstellen überprüfen, die die Domain für Cyber-Bedrohungen anfällig machen könnten. Um die Domain-Integration einzurichten, müssen Nutzer lediglich den Domainnamen in ihrer Terraform-Konfiguration angeben.

Domain Ressource

Integration von Slack

In Version 0.6 des Mondoo Terraform Providers unterstützt die Slack-Integration das Scannen von Slack-Teams, um Sicherheit und Compliance innerhalb der Kommunikationsplattform zu bewerten und zu gewährleisten. Diese Integration ist für Unternehmen, die Slack als primäres Kommunikationstool nutzen, von entscheidender Bedeutung, da sie es ihnen ermöglicht, Sicherheitsstandards direkt in ihren Slack-Umgebungen zu überwachen und aufrechtzuerhalten.

Die Integration kann verschiedene Aspekte der Slack-Nutzung und -Konfigurationen auswerten und dabei helfen, potenzielle Sicherheitsrisiken wie unangemessene Zugriffsberechtigungen oder unsichere Praktiken beim Teilen von Inhalten zu erkennen. Um diese Integration einzurichten, müssen wir sie mit entsprechenden Parametern wie dem Slack-API-Token konfigurieren.

Slack Ressource

Integration von Microsoft 365

Die Mondoo Microsoft 365 Integration, die in Version 0.7 des Mondoo Terraform Providers eingeführt wurde, ermöglicht ein kontinuierliches Scannen von Microsoft 365 Ressourcen. Diese Integration wurde entwickelt, um Fehlkonfigurationen und Schwachstellen bei Nutzern und Anwendungen zu identifizieren und kontinuierliche Sicherheitsbewertungen zu liefern. Nach der Bereitstellung aktualisiert diese Integration kontinuierlich die Sicherheitsbewertungen für neue Konten und Ressourcen, um sicherzustellen, dass die Microsoft 365-Umgebung sicher bleibt, ohne dass eine manuelle Neukonfiguration erforderlich ist.

Wir müssen auch hier sicherstellen, dass die Voraussetzungen für die Mondoo Microsoft 365 Integration erfüöerfüllt sind, wie in der Dokumentation beschrieben. Dazu gehört das Einrichten der notwendigen Berechtigungen und die Konfiguration der Einstellungen in Ihrer Microsoft 365-Umgebung, damit Mondoo umfassende Sicherheitsbewertungen effektiv durchführen kann.

Microsoft 365 Ressource

Integration von GitHub

Die Mondoo GitHub-Integration, die in Version 0.8 des Mondoo Terraform Providers eingeführt wurde, ermöglicht das kontinuierliche Scannen von GitHub-Organisationen und Repositories. Diese Integration wurde entwickelt, um Fehlkonfigurationen und Schwachstellen innerhalb einer GitHub-Umgebung zu identifizieren und sicherzustellen, dass Code-Repositories hohe Sicherheits- und Compliance-Standards einhalten.

Um diese Integration effektiv zu nutzen, müssen wir bestimmte Voraussetzungen erfüllen. Dazu gehört das Einrichten geeigneter Berechtigungen auf GitHub, um Mondoo den Zugriff für das Scannen zu ermöglichen. Dies beinhaltet in der Regel die Generierung eines GitHub-API-Tokens mit den erforderlichen Berechtigungen und die Konfiguration dieses Tokens im Mondoo-Setup, um eine sichere Verbindung zwischen Mondoo und den GitHub-Repositories herzustellen.

GitHub Ressource

Für mehr Infos darüber, wie man GitHub mit Mondoo und Terraform effektiv nutzen kann, empfehlen sich unsere Blogs! Unsere Beiträge bieten dynamische Einblicke in Sicherung von GitHub-Entwicklungsprozessen durch die Mondoo GitHub-Integration und zeigen, wie Integration von GitHub mit Terraform das Infrastrukturmanagement rationalisieren und sichern kann.

Integration von AWS

Die Mondoo AWS-Integration, verfügbar ab Version 0.9 des Mondoo Terraform Providers, ermöglicht es uns, AWS-Umgebungen kontinuierlich auf Sicherheitslücken und Fehlkonfigurationen zu scannen. Diese Integration ist entscheidend für die Aufrechterhaltung strenger Sicherheitsstandards für AWS-Ressourcen, einschließlich EC2-Instanzen, S3-Buckets und mehr.

Auch hier ist sicherzustellen, dass die Voraussetzungen für die Einrichtung dieser Integration erfüllt sind, indem die AWS-Berechtigungen und -Rollen entsprechend konfigurieret werden, wie in der Mondoo Dokumentation beschrieben. Diese Einrichtung stellt sicher, dass Mondoo umfassende Scans effektiv durchführen kann.

AWS Ressource

Diese neuesten Fortschritte für den Mondoo Terraform Provider haben wesentlich zu einem breiteren automatisierten Prozess zur Sicherung von Assets beigetragen. Wir sind stolz darauf, mit dem Mondoo-Team zusammen arbeiten zu können, um seine Fähigkeiten zu verbessern und Mondoo zu einer führenden Lösung für Infrastruktursicherheit und Compliance zu machen. Bei Interesse, es selbst auszuprobieren, empfehlen wir unseren Blogpost über die Verwendung von Mondoo mit Terraform-Automatisierung.

Erstellen von Terraform Provider Ressourcen

Wie bereits erwähnt, haben wir bei Infralovers in Zusammenarbeit mit dem Mondoo Team an der Erweiterung der Mondoo Terraform Provider Fähigkeiten gearbeitet. Wir haben unser Wissen über die Entwicklung von Terraform Providern stark erweitert und in diesem Blog der Serie über die Weiterentwicklung des Providers möchten wir unser Wissen über die Entwicklung von Ressourcen und Integrationen für Mondoo unter Verwendung des Terraform Provider Frameworks teilen.

Mondoo nutzt das terraform-plugin-codegen-framework, das eine einfache und konsistente Erweiterung des Terraform Providers ermöglicht. Der folgende Code zeigt die Grundstruktur einer solchen Ressource, die wir im Detail besprechen werden. Daher werden in den folgenden Abschnitten die verschiedenen Codes und Bausteine einer Ressource vorgestellt.

Packages und Imports

1package provider
2import (
3    "context"
4    "github.com/hashicorp/terraform-plugin-framework/resource"
5    "github.com/hashicorp/terraform-plugin-framework/resource/schema"
6    "github.com/hashicorp/terraform-plugin-framework/types"
7)

Wie in jedem Go-Code ist das erste, was wir normalerweise tun, den Package-Namen zu definieren, gefolgt vom Importieren der notwendigen Packages und Dependencies, die der Code verwenden wird. Hier gehören zu den wesentlichen Importen context für die Verwaltung von Anfragekontexten und mehrere Packages aus dem Terraform Plugin Framework, die für die Definition von Ressourcen und deren Schemata in einem Terraform-Provider wichtig sind.

Deklarieren von Datentypen

1var _ resource.Resource = (*testResourceResource)(nil)
2func NewTestResourceResource() resource.Resource {
3    return &testResourceResource{}
4}
5type testResourceResource struct{}
6type testResourceResourceModel struct {
7    Id types.String `tfsdk:"id"`
8}

Der mitgelieferte Go-Code definiert eine Terraform-Ressource für einen Anbieter, der das HashiCorp Terraform Plugin Framework verwendet. Die Ressource heißt testResourceResource und implementiert das Interface Resource.Resource. Dieses Interface benötigt mehrere Funktionen, um den Lebenszyklus der Ressource zu verwalten: Metadata, Schema, Create, Read, Update, und Delete.

Bevor wir mit der Implementierung der Logik des Lebenszyklus der Ressourcen zu beginnen, müssen wir die folgenden Typen definieren:

• testResourceResource: Dies ist eine leere Struktur, die als Empfänger für die Ressourcenfunktionen dient. Während unserer Entwicklung des Mondoo-Providers würden wir diese Struktur verwenden, um die Client-API zu deklarieren, die in Mondoos Fall eine Graphql-API ist. Dies würde es uns später ermöglichen, diesen Client aufzurufen, um Graphql-Anfragen zu stellen.
• testResourceResourceModel: Diese Struktur definiert das Schema für die Ressource und enthält zum Beispiel ein Id-Feld vom Typ types.String. Zu beachten ist, dass die Struktur ein tfsdk: "id" zum Id Feld hinzufügt. Dies teilt Terraform mit, dass die Ressource, die wir erstellen wollen, ein Feld namens "id" haben kann. Zum Beispiel:

1resource "mondoo_test_resource" "my_resource" {
2  id = "MY_ID" // This resource has a field called `id`.
3}

Metadaten Funktion

1func (r *testResourceResource) Metadata(ctx context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
2    resp.TypeName = req.ProviderTypeName + "_test_resource"
3}

Die Funktion Metadata legt den Namen des Ressourcentyps fest, indem sie test_resource an den Namen des Providers anhängt. Dies hilft Terraform, den Ressourcentyp zu identifizieren.

Schema Funktion

 1func (r *testResourceResource) Schema(ctx context.Context, req resource.SchemaRequest, resp *resource.SchemaResponse) {
 2    resp.Schema = schema.Schema{
 3        Attributes: map[string]schema.Attribute{
 4            "id": schema.StringAttribute{
 5                Computed: true,
 6                Validators: []validator.String{
 7                  // These are example validators from terraform-plugin-framework-validators
 8                  stringvalidator.LengthBetween(10, 256),
 9                  stringvalidator.RegexMatches(
10                    regexp.MustCompile(`^[a-z0-9]+$`),
11                    "must contain only lowercase alphanumeric characters",
12                  ),
13                },
14            },
15        },
16    }
17}

Die Funktion Schema definiert das Schema für die Ressource. Sie gibt an, dass die Ressource ein Attribut id hat, das eine berechnete Zeichenkette ist. Das bedeutet, dass die id vom Anbieter generiert und nicht vom Benutzer geliefert wird. Jede Ressource (z. B. ein Integrationstyp) benötigt eine eigene Reihe von Attributen, wie Namen oder Konfigurationsoptionen, die hier hinzugefügt werden müssen.

Als Erkenntnis aus dem soben Gelesenen, müssen wir die Terraform-Ressource ändern, die wir im Abschnitt "Deklarieren von Datentypen" deklariert haben:

1resource "mondoo_test_resource" "my_resource" {
2  // Since the `id` is computed we should not declare it here
3}

Darüber hinaus wird hier die Validierung der verschiedenen Felder gehandhabt, wie im obigen Beispiel Schema zu sehen ist. Wenn mehr Interesse mehr über die Validierung von Terraform-Feldern besteht, ist folgender Link zu empfehlen.

Create Funktion

 1func (r *testResourceResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
 2    var data testResourceResourceModel
 3    // Read Terraform plan data into the model
 4    resp.Diagnostics.Append(req.Plan.Get(ctx, &data)...)
 5    if resp.Diagnostics.HasError() {
 6        return
 7    }
 8    // Create API call logic
 9    // Example data value setting
10    data.Id = types.StringValue("example-id")
11    // Save data into Terraform state
12    resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
13}

Die Funktion Create behandelt die Erstellung der Ressource. Sie liest den geplanten Status von Terraform in ein testResourceResourceModel Feld mit einem Platzhalterwert ("example-id") und speichert diesen Status zurück in Terraform. Dies wäre ein richtiger Ort, um den zuvor deklarierten Client aufzurufen und ihn zu verwenden, um unsere Ressource zu erstellen und die Werte, die wir von dem Aufruf zurückbekommen, in unserer Terraform-Statusdatei zu speichern.

Read Funktion

 1func (r *testResourceResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
 2    var data testResourceResourceModel
 3    // Read Terraform prior state data into the model
 4    resp.Diagnostics.Append(req.State.Get(ctx, &data)...)
 5    if resp.Diagnostics.HasError() {
 6        return
 7    }
 8    // Read API call logic
 9    // Save updated data into Terraform state
10    resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
11}

Die Funktion Read liest den aktuellen Zustand der Ressource aus Terraform in eine testResourceResourceModel Instanz. Sie aktualisiert dann den Zustand in Terraform und stellt sicher, dass alle Änderungen, die außerhalb von Terraform vorgenommen werden, im Zustand reflektiert werden.

Update Funktion

 1func (r *testResourceResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
 2    var data testResourceResourceModel
 3    // Read Terraform plan data into the model
 4    resp.Diagnostics.Append(req.Plan.Get(ctx, &data)...)
 5    if resp.Diagnostics.HasError() {
 6        return
 7    }
 8    // Update API call logic
 9    // Save updated data into Terraform state
10    resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
11}

Die Update-Funktion ist ähnlich wie die Create-Funktion. Sie liest den geplanten Zustand, führt alle notwendigen Aktualisierungen durch und speichert den aktualisierten State zurück in Terraform.

Delete Funktion

1func (r *testResourceResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
2    var data testResourceResourceModel
3    // Read Terraform prior state data into the model
4    resp.Diagnostics.Append(req.State.Get(ctx, &data)...)
5    if resp.Diagnostics.HasError() {
6        return
7    }
8    // Delete API call logic
9}

Die Funktion Delete liest den aktuellen Zustand der Ressource und führt alle notwendigen Bereinigungen durch. Im Gegensatz zu den anderen Funktionen speichert sie keinen Zustand zurück in Terraform, da die Ressource gelöscht wird.

Code Zusammenfassung

Der Code bietet eine grundlegende Implementierung einer Terraform-Ressource unter Verwendung des HashiCorp Terraform Plugin Frameworks. Er enthält Funktionen zur Verwaltung des Lebenszyklus der Ressource und definiert ein einfaches Schema mit einem einzigen berechneten id-Attribut. Die eigentliche API-Aufruflogik zum Erstellen, Lesen, Aktualisieren und Löschen der Ressource ist nicht implementiert und müsste an den durch Kommentare gekennzeichneten Stellen für die jeweiligen Integrationstypen hinzugefügt werden.

Zusammenfassung

In diesem Blog-Beitrag haben wir uns mit den Fortschritten des Mondoo Terraform Providers beschäftigt, die durch unsere Zusammenarbeit mit Mondoo erreicht wurden. Er hebt die Integration von Mondoo mit verschiedenen Integrationstypen hervor, die die Automatisierung von Sicherheit und Compliance in IT-Infrastrukturen verbessern. Unser Beitrag stellt neue Ressourcen und Integrationstypen vor, die seit April 2024 eingeführt wurden, und unterstreicht die Einfachheit und Effektivität der Sicherung von Assets durch automatisierte Prozesse mit Terraform. Wir haben auch die technischen Aspekte dieser Integrationen demonstriert und Einblicke in das Implementieren der Terraform-Anbieter gegeben. Bleiben Sie dran für unsere nächsten Blogs innerhalb dieser Serie über Data Sources und Imports mit Terraform.