Dataklassificering i .NET

Dataklassificering hjälper dig att kategorisera (eller klassificera) data baserat på dess känslighets- och skyddsnivå. Med DataClassification strukturen kan du märka känslig information och tillämpa principer baserat på dessa etiketter.

• DataClassification.TaxonomyName: Identifierar klassificeringssystemet.
• DataClassification.Value: Representerar den specifika etiketten i taxonomi.

I vissa situationer kan du behöva ange att data uttryckligen inte har någon dataklassificering, detta uppnås med DataClassification.None. På samma sätt kan du behöva ange att dataklassificeringen är okänd – använd DataClassification.Unknown i dessa fall.

Installera paketet

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

dotnet add package Microsoft.Extensions.Compliance.Abstractions

dotnet package add Microsoft.Extensions.Compliance.Abstractions

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

Skapa anpassade klassificeringar

Definiera anpassade klassificeringar genom att skapa static medlemmar för olika typer av känsliga data. Detta ger dig ett konsekvent sätt att märka och hantera data i hela appen. Överväg följande exempelklass:

using Microsoft.Extensions.Compliance.Classification;

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

    internal static DataClassification PrivateInformation => new(Name, nameof(PrivateInformation));
    internal static DataClassification CreditCardNumber => new(Name, nameof(CreditCardNumber));
    internal static DataClassification SocialSecurityNumber => new(Name, nameof(SocialSecurityNumber));

    internal static DataClassificationSet PrivateAndSocialSet => new(PrivateInformation, SocialSecurityNumber);
}

Om du vill dela din anpassade klassificeringstaxonomi med andra appar bör den här klassen och dess medlemmar vara public i stället för internal. Du kan till exempel ha ett delat bibliotek som innehåller anpassade klassificeringar som du kan använda i flera program.

DataClassificationSet gör att du kan skapa flera dataklassificeringar i en enda uppsättning. På så sätt kan du klassificera dina data med flera dataklassificeringar. Dessutom använder .NET-redigerings-API:erna en DataClassificationSet.

Skapa anpassade klassificeringsattribut

Skapa anpassade attribut baserat på dina anpassade klassificeringar. Använd dessa attribut för att tagga dina data med rätt klassificering. Överväg följande anpassade attributklassdefinition:

public sealed class PrivateInformationAttribute : DataClassificationAttribute
{
    public PrivateInformationAttribute()
        : base(MyTaxonomyClassifications.PrivateInformation)
    {
    }
}

Koden ovan deklarerar ett privat informationsattribut, som är en underklass av typen DataClassificationAttribute . Den definierar en parameterlös konstruktor och skickar det anpassade DataClassification till dess base.

Inställningar för bindning av data för klassificering

Om du vill binda dina dataklassificeringsinställningar använder du .NET-konfigurationssystemet. Om du till exempel använder en JSON-konfigurationsprovider kan din appsettings.json definieras på följande sätt:

{
    "Key": {
        "PhoneNumber": "MyTaxonomy:PrivateInformation",
        "ExampleDictionary": {
            "CreditCard": "MyTaxonomy:CreditCardNumber",
            "SSN": "MyTaxonomy:SocialSecurityNumber"
        }
    }
}

Överväg nu följande metod för alternativmönster som binder dessa konfigurationsinställningar till TestOptions objektet:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Compliance.Classification;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Options;

public class TestOptions
{
    public DataClassification? PhoneNumber { get; set; }
    public IDictionary<string, DataClassification> ExampleDictionary { get; set; } = new Dictionary<string, DataClassification>();
}

class Program
{
    static void Main(string[] args)
    {
        // Build configuration from an external json file.
        IConfiguration configuration = new ConfigurationBuilder()
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .Build();

        // Setup DI container and bind the configuration section "Key" to TestOptions.
        IServiceCollection services = new ServiceCollection();
        services.Configure<TestOptions>(configuration.GetSection("Key"));

        // Build the service provider.
        IServiceProvider serviceProvider = services.BuildServiceProvider();

        // Get the bound options.
        TestOptions options = serviceProvider.GetRequiredService<IOptions<TestOptions>>().Value;

        // Simple output demonstrating binding results.
        Console.WriteLine("Configuration bound to TestOptions:");
        Console.WriteLine($"PhoneNumber: {options.PhoneNumber}");
        foreach (var item in options.ExampleDictionary)
        {
            Console.WriteLine($"{item.Key}: {item.Value}");
        }
    }
}