Dela via

Dataredigering i .NET

Med redigering kan du sanera eller maskera känslig information i loggar, felmeddelanden eller andra utdata. Detta håller dig kompatibel med sekretessregler och skyddar känsliga data. Det är användbart i appar som hanterar personuppgifter, ekonomisk information eller andra konfidentiella datapunkter.

Installera redigeringspaket

Kom igång genom att 📦 installera NuGet-paketet Microsoft.Extensions.Compliance.Redaction :

dotnet add package Microsoft.Extensions.Compliance.Redaction

Eller om du använder .NET 10+ SDK:

dotnet package add Microsoft.Extensions.Compliance.Redaction

Tillgängliga redigeringsfunktioner

Redaktörer ansvarar för att bearbeta känsliga data. De redigerar, ersätter eller maskerar känslig information. Överväg följande tillgängliga redigeringsprogram som tillhandahålls av biblioteket:

Användningsexempel

Om du vill använda de inbyggda redigeringsfunktionerna måste du registrera de tjänster som krävs. Registrera tjänsterna med någon av de tillgängliga AddRedaction metoderna enligt beskrivningen i följande lista:

Konfigurera en redaktör

Hämta redigeringsfunktioner vid körning med hjälp av en IRedactorProvider. Du kan implementera din egen leverantör och registrera den i anropet AddRedaction , eller använda standardprovidern. Konfigurera redigeringsfunktioner med hjälp av följande IRedactionBuilder metoder:

// 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>();

Givet den här dataklassificeringen i din kod:

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));
}

Konfigurera HMAC-redigeringsverktyget

Konfigurera HMAC-redigeringsverktyget med hjälp av följande IRedactionBuilder metoder:

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));
});

Du kan också konfigurera det på det här sättet:

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

Ta med det här avsnittet i JSON-konfigurationsfilen:

{
    "HmacRedactorOptions": {
        "KeyId": 1234567890,
        "Key": "1234567890abcdefghijklmnopqrstuvwxyz"
    }
}
  • HmacRedactorOptions kräver att dess egenskaper HmacRedactorOptions.Key och HmacRedactorOptions.KeyId är inställda.
  • Key bör vara i bas 64-format och minst 44 tecken långt. Använd en distinkt nyckel för varje större distribution av en tjänst. Håll nyckelmaterialet hemligt och rotera det regelbundet.
  • KeyId läggs till i varje redigerat värde för att identifiera nyckeln som används för att hasha datan.
  • Olika nyckel-ID:er innebär att värdena är orelaterade och inte kan användas för korrelation.

Anmärkning

HmacRedactor är fortfarande experimentellt, så de föregående metoderna orsakar EXTEXP0002 varningen som indikerar att den ännu inte är stabil. Om du vill använda den lägger du till <NoWarn>$(NoWarn);EXTEXP0002</NoWarn> i projektfilen eller lägger till #pragma warning disable EXTEXP0002 runt anropen till SetHmacRedactor.

Konfigurera en anpassad redigerare

Om du vill skapa en anpassad redigerare definierar du en underklass som ärver från Redactor:

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;
    }
}

Skapa en anpassad redaktörsleverantör

Gränssnittet IRedactorProvider tillhandahåller instanser av redaktörer baserat på dataklassificering. Om du vill skapa en skräddarsydd redaktörsleverantör, ärver du från IRedactorProvider enligt följande exempel:

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;
}

Registrera känslig information

Loggning är en vanlig källa till oavsiktlig dataexponering. Känslig information som personuppgifter, autentiseringsuppgifter eller ekonomisk information bör aldrig skrivas till loggar i oformaterad text. Du kan förhindra detta genom att alltid använda redigering när du loggar potentiellt känsliga data.

Steg för att logga känsliga data

  1. Installera paketet telemetritillägg: Installera Microsoft.Extensions.Telemetry för att kunna använda den utökade loggern för att aktivera redigeringsfunktionen.
  2. Konfigurera redigering: Integrera redigeringar med loggningspipelinen genom att anropa AddRedaction(IServiceCollection) metoden för att automatiskt sanera eller maskera känsliga fält innan de skrivs till loggar.
  3. Identifiera känsliga fält: Ta reda på vilka data i ditt program som är känsliga och kräver skydd och markera dem med lämplig dataklassificering.
  4. Granska loggutdata: Granska regelbundet loggarna för att säkerställa att inga känsliga data exponeras.

Exempel: Redigera data i loggar

När du använder Microsoft.Extensions.Logging kan du kombinera redigering med loggning på följande sätt:

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");
}

Utdata bör vara så här:

User SSN: *****

Detta säkerställer att känsliga data redigeras innan de loggas, vilket minskar risken för dataläckor.

  • Last updated on