Datenanonymisierung in .NET

Redaction hilft Ihnen, vertrauliche Informationen in Protokollen, Fehlermeldungen oder anderen Ausgaben zu bereinigen oder zu maskieren. Dadurch bleiben Sie den Datenschutzregeln entsprechend und schützen vertrauliche Daten. Es ist nützlich in Apps, die personenbezogene Daten, Finanzinformationen oder andere vertrauliche Datenpunkte verarbeiten.

Installieren des Redaction-Pakets

Installieren Sie zunächst das 📦 NuGet-Paket "Microsoft.Extensions.Compliance.Redaction NuGet":

.NET CLI

dotnet add package Microsoft.Extensions.Compliance.Redaction

Oder, wenn Sie .NET 10+ SDK verwenden:

dotnet package add Microsoft.Extensions.Compliance.Redaction

PaketReferenz

<ItemGroup>
  <PackageReference Include="Microsoft.Extensions.Compliance.Redaction"
                    Version="*" />
</ItemGroup>

Verfügbare Redakteure

Redakteure sind für die Bearbeitung vertraulicher Daten verantwortlich. Sie redigieren, ersetzen oder maskieren vertrauliche Informationen. Berücksichtigen Sie die folgenden verfügbaren Redactors, die von der Bibliothek bereitgestellt werden:

• Das ErasingRedactor ersetzt jede Eingabe durch eine leere Zeichenfolge.
• HmacRedactor verwendet HMACSHA256 zum Verschlüsseln von Daten, die geschwärzt werden.

Verwendungsbeispiel

Um die integrierten Redactors zu verwenden, müssen Sie die erforderlichen Dienste registrieren. Registrieren Sie die Dienste mithilfe einer der verfügbaren AddRedaction Methoden, wie in der folgenden Liste beschrieben:

• AddRedaction(IServiceCollection): Registriert eine Implementierung von IRedactorProvider in der IServiceCollection.
• AddRedaction(IServiceCollection, Action<IRedactionBuilder>): Registriert eine Implementierung von IRedactorProvider in IServiceCollection und konfiguriert die verfügbaren Redaktoren mit dem angegebenen configure-Delegat.

Konfigurieren eines Redakteurs

Abrufen von Redactors zur Laufzeit mithilfe eines IRedactorProvider. Sie können Ihren eigenen Anbieter implementieren und innerhalb des AddRedaction Anrufs registrieren oder den Standardanbieter verwenden. Konfigurieren Sie Redakteure mit den folgenden IRedactionBuilder Methoden:

// This will use the default redactor, which is the ErasingRedactor
var serviceCollection = new ServiceCollection();
serviceCollection.AddRedaction();

// Using the default redactor provider:
serviceCollection.AddRedaction(redactionBuilder =>
{
    // Assign a redactor to use for a set of data classifications.
    redactionBuilder.SetRedactor<StarRedactor>(
        MyTaxonomyClassifications.Private,
        MyTaxonomyClassifications.Personal);
    // Assign a fallback redactor to use when processing classified data for which no specific redactor has been registered.
    // The `ErasingRedactor` is the default fallback redactor. If no redactor is configured for a data classification then the data will be erased.
    redactionBuilder.SetFallbackRedactor<MyFallbackRedactor>();
});

// Using a custom redactor provider:
builder.Services.AddSingleton<IRedactorProvider, StarRedactorProvider>();

Aufgrund dieser Datenklassifizierung in Ihrem Code:

public static class MyTaxonomyClassifications
{
    public static string Name => "MyTaxonomy";

    public static DataClassification Private => new(Name, nameof(Private));
    public static DataClassification Public => new(Name, nameof(Public));
    public static DataClassification Personal => new(Name, nameof(Personal));
}

Konfigurieren des HMAC-Redactors

Konfigurieren Sie den HMAC-Redactor mit den folgenden IRedactionBuilder Methoden:

var serviceCollection = new ServiceCollection();
serviceCollection.AddRedaction(builder =>
{
    builder.SetHmacRedactor(
        options =>
        {
            options.KeyId = 1234567890;
            options.Key = Convert.ToBase64String("1234567890abcdefghijklmnopqrstuvwxyz");
        },

        // Any data tagged with Personal or Private attributes will be redacted by the Hmac redactor.
        MyTaxonomyClassifications.Personal, MyTaxonomyClassifications.Private,

        // "DataClassificationSet" lets you compose multiple data classifications:
        // For example, here the Hmac redactor will be used for data tagged
        // with BOTH Personal and Private (but not one without the other).
        new DataClassificationSet(MyTaxonomyClassifications.Personal,
                                  MyTaxonomyClassifications.Private));
});

Alternativ können Sie sie auf diese Weise konfigurieren:

var serviceCollection = new ServiceCollection();
serviceCollection.AddRedaction(builder =>
{
    builder.SetHmacRedactor(
        Configuration.GetSection("HmacRedactorOptions"), MyTaxonomyClassifications.Personal);
});

Fügen Sie diesen Abschnitt in die JSON-Konfigurationsdatei ein:

{
    "HmacRedactorOptions": {
        "KeyId": 1234567890,
        "Key": "1234567890abcdefghijklmnopqrstuvwxyz"
    }
}

• Das HmacRedactorOptions erfordert, dass die Eigenschaften HmacRedactorOptions.Key und HmacRedactorOptions.KeyId festgelegt werden.
• Das Key Format sollte im Basis-64-Format und mindestens 44 Zeichen lang sein. Verwenden Sie einen eindeutigen Schlüssel für jede wichtige Bereitstellung eines Diensts. Halten Sie das Schlüsselmaterial geheim, und drehen Sie es regelmäßig.
• Der KeyId Wert wird an jeden redacted-Wert angefügt, um den Schlüssel zu identifizieren, der zum Hashen der Daten verwendet wird.
• Unterschiedliche Schlüssel-IDs bedeuten, dass die Werte nicht miteinander verknüpft sind und nicht für die Korrelation verwendet werden können.

Hinweis

Das HmacRedactor ist noch experimentell, sodass die vorhergehenden Methoden die EXTEXP0002-Warnung verursachen, dass sie noch nicht stabil sind. Fügen Sie <NoWarn>$(NoWarn);EXTEXP0002</NoWarn> Ihrer Projektdatei hinzu, oder fügen Sie #pragma warning disable EXTEXP0002 bei den Aufrufen von SetHmacRedactor hinzu.

Konfigurieren eines benutzerdefinierten Redakteurs

Um einen benutzerdefinierten Editor zu erstellen, definieren Sie eine Unterklasse, die von Redactor erbt:

public sealed class StarRedactor : Redactor
{
    private const string Stars = "****";

    public override int GetRedactedLength(ReadOnlySpan<char> input) => Stars.Length;

    public override int Redact(ReadOnlySpan<char> source, Span<char> destination)
    {
        Stars.CopyTo(destination);

        return Stars.Length;
    }
}

Erstellen eines benutzerdefinierten Redactor-Anbieters

Die IRedactorProvider-Schnittstelle stellt Instanzen von Redactors basierend auf der Datenklassifizierung bereit. Um einen benutzerdefinierten Redactor-Anbieter zu erstellen, erben Sie von IRedactorProvider, wie im folgenden Beispiel gezeigt:

using Microsoft.Extensions.Compliance.Classification;
using Microsoft.Extensions.Compliance.Redaction;

public sealed class StarRedactorProvider : IRedactorProvider
{
    private static readonly StarRedactor _starRedactor = new();

    public static StarRedactorProvider Instance { get; } = new();

    public Redactor GetRedactor(DataClassificationSet classifications) => _starRedactor;
}

Protokollierung vertraulicher Informationen

Die Protokollierung ist eine häufige Quelle für versehentliche Datenexposition. Vertrauliche Informationen wie personenbezogene Daten, Anmeldeinformationen oder Finanzdetails sollten niemals in Protokolle mit Nur-Text geschrieben werden. Um dies zu verhindern, verwenden Sie beim Protokollieren potenziell vertraulicher Daten immer die Schwärzung.

Schritte zum Protokollieren vertraulicher Daten

1. Installieren Sie das Telemetrieerweiterungspaket: Installieren Sie Microsoft.Extensions.Telemetry , um den erweiterten Logger verwenden zu können, um die Redaction-Funktion zu aktivieren.
2. Einrichten von Redaction: Integrieren Sie Redactors in Ihre Protokollierungspipeline, indem Sie die AddRedaction(IServiceCollection) Methode aufrufen, um vertrauliche Felder automatisch zu bereinigen oder zu maskieren, bevor sie in Protokolle geschrieben werden.
3. Identifizieren vertraulicher Felder: Sie wissen, welche Daten in Ihrer Anwendung vertraulich sind und schutz erforderlich sind, und kennzeichnen Sie sie mit der entsprechenden Datenklassifizierung.
4. Überprüfen Sie die Protokollausgabe: Überwachen Sie ihre Protokolle regelmäßig, um sicherzustellen, dass keine vertraulichen Daten verfügbar gemacht werden.

Beispiel: Bearbeiten von Daten in Protokollen

Wenn Sie Microsoft.Extensions.Logging verwenden, können Sie Die Redaction mit der Protokollierung wie folgt kombinieren:

using Microsoft.Extensions.Telemetry;
using Microsoft.Extensions.Compliance.Redaction;

var services = new ServiceCollection();
services.AddLogging(builder =>
{
    // Enable redaction.
    builder.EnableRedaction();
});

services.AddRedaction(builder =>
{
    // configure redactors for your data classifications
    builder.SetRedactor<StarRedactor>(MyTaxonomyClassifications.Private);
});
// Use annotations to mark sensitive data.
// For example, apply the Private classification to SSN data.
[LoggerMessage(0, LogLevel.Information, "User SSN: {SSN}")]
public static partial void LogPrivateInformation(
    this ILogger logger,
    [MyTaxonomyClassifications.Private] string SSN);

public void TestLogging()
{
    LogPrivateInformation("MySSN");
}

Die Ausgabe sollte wie folgt aussehen:

User SSN: *****

Dadurch wird sichergestellt, dass vertrauliche Daten vor der Protokollierung redagiert werden, wodurch das Risiko von Datenlecks verringert wird.