Konfigurieren der Tokenbindung mit mTLS Proof-of-Possession (mTLS PoP)

Hinweis

Nicht alle Clients dürfen mTLS-PoP-Zertifikate abrufen, da sich dieses Feature derzeit in der privaten Vorschau befindet.

Zertifikattokenbindung (auch bekannt als mTLS PoP - Mutual TLS Proof-of-Possession) ist ein erweitertes Sicherheitsfeature, das Zugriffstoken kryptografisch an ein bestimmtes X.509-Zertifikat bindet. RFC 8705 beschreibt diese Bindung. Die Bindung stellt sicher, dass ein Angreifer es auch dann nicht verwenden kann, wenn ein Token abgefangen wird, ohne den entsprechenden privaten Schlüssel zu besitzen.

Grundlegendes zur Funktionsweise der Tokenbindung

In den folgenden Schritten wird der Ablauf der Tokenbindung von der Erfassung bis zur Überprüfung beschrieben.

Token Acquisition: Beim Anfordern eines Zugriffstokens mit aktivierter Tokenbindung enthält Microsoft Identity Web den Fingerabdruck des Zertifikats in die Tokenanforderung.
Tokenbindung: Der Autorisierungsserver bettet einen cnf (Bestätigungs)-Anspruch in das ausgestellte Token ein, das den SHA-256-Fingerabdruck des Zertifikats enthält (x5t#S256)
API-Aufruf: Der Client stellt sowohl das gebundene Token als auch das Zertifikat beim Aufrufen der downstream-API dar.
Überprüfung: Die API überprüft, ob das angezeigte Zertifikat dem Zertifikatverweis im Anspruch des cnf Tokens entspricht.

sequenceDiagram
    participant Client
    participant EntraID as Microsoft Entra ID
    participant API

    Client->>EntraID: Token request with certificate thumbprint
    EntraID->>Client: Token with cnf claim (bound to certificate)
    Client->>API: MTLS_POP token + Client certificate
    API->>API: Validate token and certificate binding
    API->>Client: Protected resource

Überprüfen der Sicherheitsvorteile

Die Tokenbindung bietet die folgenden Vorteile zum Sichern Ihrer Anwendungen.

Tokendiebstahlschutz: Gestohlene Token sind ohne das entsprechende Zertifikat nutzlos.
Replay Attack Prevention: Token können nicht von verschiedenen Clients wiedergegeben werden
Erweiterte Authentifizierung: Kombiniert "etwas, das Sie haben" (Zertifikat) mit herkömmlichen OAuth2-Flüssen
Zero Trust Architecture: Richtet sich an zero trust Prinzipien aus, indem Anmeldeinformationen an bestimmte Geräte gebunden werden.

Konfigurieren der Tokenbindung

Richten Sie sowohl die Clientanwendung als auch den API-Server ein, um die MTLS-PoP-Tokenbindung zu aktivieren.

Konfigurieren der Clientanwendung

Führen Sie die folgenden Schritte aus, um die Clientanwendung für die Tokenbindung zu konfigurieren.

1. Konfigurieren von Microsoft Entra ID Einstellungen

Konfigurieren Sie in Ihrem appsettings.json Ihre Microsoft Entra-Einstellungen, einschließlich des Zertifikats:

{
  "AzureAd": {
    "Instance": "https://login.microsoftonline.com/",
    "TenantId": "your-tenant-id",
    "ClientId": "your-client-id",
    "ClientCredentials": [
      {
        "SourceType": "StoreWithDistinguishedName",
        "CertificateStorePath": "CurrentUser/My",
        "CertificateDistinguishedName": "CN=YourCertificate"
      }
    ],
    "SendX5c": true
  }
}

2. Konfigurieren der downstream-API mit Tokenbindung

Konfigurieren Sie den nachgeschalteten API-Abschnitt mit dem MTLS_POP Protokollschema:

{
  "DownstreamApi": {
    "BaseUrl": "https://api.contoso.com/",
    "RelativePath": "api/data",
    "ProtocolScheme": "MTLS_POP",
    "RequestAppToken": true,
    "Scopes": [ "api://your-api-scope/.default" ]
  }
}

Wichtige Konfigurationseigenschaften:

ProtocolScheme: Muss auf "MTLS_POP" gesetzt werden, um die Tokenbindung zu aktivieren.
RequestAppToken: Muss sein true (Tokenbindung unterstützt derzeit nur Anwendungstoken)
Scopes: API-Bereiche, die für den nachgeschalteten API-Aufruf erforderlich sind

3. Registrieren von Diensten

Registrieren Sie den nachgeschalteten API-Dienst im Startcode Ihrer Anwendung. Das folgende Beispiel zeigt sowohl Konsolen-App als auch ASP.NET Core Ansätze.

using Microsoft.Identity.Web;

var builder = WebApplication.CreateBuilder(args);

// Option 1: Using TokenAcquirerFactory (for console apps, background services)
var tokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance();

tokenAcquirerFactory.Services.AddDownstreamApi(
    "DownstreamApi",
    tokenAcquirerFactory.Configuration.GetSection("DownstreamApi"));

var serviceProvider = tokenAcquirerFactory.Build();

// Option 2: Using ASP.NET Core DI (for web apps, web APIs)
builder.Services.AddAuthentication()
    .AddMicrosoftIdentityWebApp(builder.Configuration.GetSection("AzureAd"));

builder.Services.AddDownstreamApi(
    "DownstreamApi",
    builder.Configuration.GetSection("DownstreamApi"));

Konfigurieren des API-Servers

Die downstreame API muss sowohl das Token als auch die Zertifikatbindung überprüfen. Hier ist ein vollständiges Beispiel:

1. Registrieren von Authentifizierungshandlern

using Microsoft.Identity.Web;

var builder = WebApplication.CreateBuilder(args);

// Add standard JWT Bearer authentication
builder.Services.AddMicrosoftIdentityWebApiAuthentication(builder.Configuration);

// Add custom MTLS_POP authentication handler
builder.Services.AddAuthentication()
    .AddScheme<AuthenticationSchemeOptions, MtlsPopAuthenticationHandler>(
        "MTLS_POP",
        options => { });

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();
app.Run();

2. Implementieren des MTLS-PoP-Authentifizierungshandlers

using System.Security.Claims;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text.Encodings.Web;
using System.Text.Json;
using Microsoft.AspNetCore.Authentication;
using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.JsonWebTokens;
using Microsoft.IdentityModel.Tokens;

public class MtlsPopAuthenticationHandler : AuthenticationHandler<AuthenticationSchemeOptions>
{
    public const string ProtocolScheme = "MTLS_POP";

    public MtlsPopAuthenticationHandler(
        IOptionsMonitor<AuthenticationSchemeOptions> options,
        ILoggerFactory logger,
        UrlEncoder encoder)
        : base(options, logger, encoder)
    {
    }

    protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        // 1. Extract the MTLS_POP authorization header
        var authHeader = Request.Headers.Authorization.FirstOrDefault();
        if (string.IsNullOrEmpty(authHeader) ||
            !authHeader.StartsWith($"{ProtocolScheme} ", StringComparison.OrdinalIgnoreCase))
        {
            return AuthenticateResult.NoResult();
        }

        var authToken = authHeader.Substring($"{ProtocolScheme} ".Length).Trim();

        try
        {
            // 2. Parse the JWT token
            var handler = new JsonWebTokenHandler();
            var token = handler.ReadJsonWebToken(authToken);

            // 3. Extract the 'cnf' claim
            var cnfClaim = token.Claims.FirstOrDefault(c => c.Type == "cnf");
            if (cnfClaim == null)
            {
                return AuthenticateResult.Fail("Missing 'cnf' claim in MTLS_POP token");
            }

            // 4. Extract certificate thumbprint from cnf claim
            var cnfJson = JsonDocument.Parse(cnfClaim.Value);
            if (!cnfJson.RootElement.TryGetProperty("x5t#S256", out var x5tS256Element))
            {
                return AuthenticateResult.Fail("Missing 'x5t#S256' in cnf claim");
            }

            var expectedThumbprint = x5tS256Element.GetString();

            // 5. Get client certificate from TLS connection
            var clientCert = Context.Connection.ClientCertificate;
            if (clientCert != null)
            {
                var actualThumbprint = GetCertificateThumbprint(clientCert);

                // 6. Validate certificate binding
                if (!string.Equals(actualThumbprint, expectedThumbprint,
                    StringComparison.OrdinalIgnoreCase))
                {
                    return AuthenticateResult.Fail(
                        "Certificate thumbprint mismatch with cnf claim");
                }
            }

            // 7. Create claims principal
            var claims = token.Claims.Select(c => new Claim(c.Type, c.Value)).ToList();
            var identity = new ClaimsIdentity(claims, ProtocolScheme);
            var principal = new ClaimsPrincipal(identity);
            var ticket = new AuthenticationTicket(principal, ProtocolScheme);

            return AuthenticateResult.Success(ticket);
        }
        catch (Exception ex)
        {
            Logger.LogError(ex, "Error validating mTLS PoP token");
            return AuthenticateResult.Fail($"Validation error: {ex.Message}");
        }
    }

    private static string GetCertificateThumbprint(X509Certificate2 certificate)
    {
        using var sha256 = SHA256.Create();
        var hash = sha256.ComputeHash(certificate.RawData);
        return Base64UrlEncoder.Encode(hash);
    }
}

Verwenden der Tokenbindung in Anwendungen

Die folgenden Beispiele zeigen, wie MTLS PoP-Tokenbindung in verschiedene Anwendungstypen integriert wird.

Aufrufen von APIs aus einer Konsolen- oder Daemonanwendung

Im folgenden Beispiel wird eine Konsolen- oder Daemonanwendung veranschaulicht, die eine nachgeschaltete API mit mTLS PoP-Tokenbindung aufruft.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Identity.Abstractions;
using Microsoft.Identity.Web;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Create and configure token acquirer
        var tokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance();

        tokenAcquirerFactory.Services.AddDownstreamApi(
            "SecureApi",
            tokenAcquirerFactory.Configuration.GetSection("SecureApi"));

        var serviceProvider = tokenAcquirerFactory.Build();

        // Get IDownstreamApi instance
        var downstreamApi = serviceProvider.GetRequiredService<IDownstreamApi>();

        // Call API with mTLS PoP token
        var response = await downstreamApi.GetForAppAsync<ApiResponse>("SecureApi");

        Console.WriteLine($"Result: {response?.Data}");
    }
}

public class ApiResponse
{
    public string? Data { get; set; }
}

Aufrufen von APIs aus einer ASP.NET Core Webanwendung

Das folgende Beispiel zeigt einen Controller, der eine nachgeschaltete API mit mTLS PoP-Tokenbindung aufruft.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Identity.Abstractions;

[ApiController]
[Route("api/[controller]")]
public class DataController : ControllerBase
{
    private readonly IDownstreamApi _downstreamApi;
    private readonly ILogger<DataController> _logger;

    public DataController(
        IDownstreamApi downstreamApi,
        ILogger<DataController> logger)
    {
        _downstreamApi = downstreamApi;
        _logger = logger;
    }

    [HttpGet]
    public async Task<IActionResult> GetSecureData()
    {
        try
        {
            // Call downstream API with mTLS PoP token binding
            var data = await _downstreamApi.GetForAppAsync<SecureData>(
                "SecureApi");

            return Ok(data);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to retrieve secure data");
            return StatusCode(500, "Failed to retrieve data");
        }
    }
}

public class SecureData
{
    public string? Id { get; set; }
    public string? Value { get; set; }
}

Programmgesteuertes Konfigurieren von DownstreamApiOptions

Im folgenden Beispiel werden mTLS-PoP-Optionen direkt in Code anstelle von Konfigurationsdateien festgelegt.

using Microsoft.Identity.Abstractions;
using Microsoft.Identity.Web;

public class SecureApiService
{
    private readonly IDownstreamApi _downstreamApi;

    public SecureApiService(IDownstreamApi downstreamApi)
    {
        _downstreamApi = downstreamApi;
    }

    public async Task<T?> CallSecureApiAsync<T>(string endpoint) where T : class
    {
        return await _downstreamApi.GetForAppAsync<T>(
            serviceName: null,
            downstreamApiOptionsOverride: options =>
            {
                options.BaseUrl = "https://api.secure.com";
                options.RelativePath = endpoint;
                options.ProtocolScheme = "MTLS_POP";
                options.RequestAppToken = true;
                options.Scopes = new[] { "api://secure-api/.default" };
            });
    }
}

Verwenden von MicrosoftIdentityMessageHandler mit Tokenbindung

MicrosoftIdentityMessageHandler unterstützt die MTLS-PoP-Tokenbindung über die AddMicrosoftIdentityMessageHandler Erweiterungsmethoden. Wenn ProtocolScheme auf "MTLS_POP" gesetzt ist, erwirbt der Handler automatisch ein gebundenes Token und sendet Anfragen über einen mTLS-konfigurierten HTTP-Client.

Inline-Optionen konfigurieren

Im folgenden Beispiel wird ein HTTP-Client mit inline mTLS PoP-Konfiguration registriert und die Verwendung in einem Dienst veranschaulicht.

// Program.cs
services.AddHttpClient("MtlsPopClient", client =>
{
    client.BaseAddress = new Uri("https://api.contoso.com");
})
.AddMicrosoftIdentityMessageHandler(options =>
{
    options.Scopes.Add("api://contoso/.default");
    options.ProtocolScheme = "MTLS_POP";
    options.RequestAppToken = true;
});

// Usage in a service
public class SecureApiService
{
    private readonly HttpClient _httpClient;

    public SecureApiService(IHttpClientFactory factory)
    {
        _httpClient = factory.CreateClient("MtlsPopClient");
    }

    public async Task<string> GetSecureDataAsync()
    {
        // Authentication and mTLS certificate binding are automatic
        var response = await _httpClient.GetAsync("/api/secure-data");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

Konfiguration aus appsettings.json laden

Sie können tokenbindungseinstellungen auch aus Ihrer Konfigurationsdatei laden.

appsettings.json:

{
  "DownstreamApis": {
    "SecureApi": {
      "Scopes": ["api://secure-api/.default"],
      "ProtocolScheme": "MTLS_POP",
      "RequestAppToken": true
    }
  }
}

Program.cs: Der folgende Code registriert den HTTP-Client mithilfe des Konfigurationsabschnitts.

services.AddHttpClient("SecureApiClient", client =>
{
    client.BaseAddress = new Uri("https://secure-api.example.com");
})
.AddMicrosoftIdentityMessageHandler(
    configuration.GetSection("DownstreamApis:SecureApi"),
    "SecureApi");

Tokenbindung pro Anforderung anwenden

Verwenden Sie die Optionen pro Anforderung, wenn bei einigen Anforderungen die Tokenbindung benötigt wird und bei anderen nicht.

services.AddHttpClient("FlexibleClient")
    .AddMicrosoftIdentityMessageHandler();

// In a service:
public async Task<string> CallWithTokenBindingAsync()
{
    var request = new HttpRequestMessage(HttpMethod.Get, "https://api.contoso.com/secure")
        .WithAuthenticationOptions(options =>
        {
            options.Scopes.Add("api://contoso/.default");
            options.ProtocolScheme = "MTLS_POP";
            options.RequestAppToken = true;
        });

    var response = await _httpClient.SendAsync(request);
    response.EnsureSuccessStatusCode();
    return await response.Content.ReadAsStringAsync();
}

Weitere Informationen finden Sie in der Dokumentation zu MicrosoftIdentityMessageHandlerbenutzerdefinierten APIs.

Erstellung eines maßgeschneiderten HttpClient mit Anbieter für Autorisierungs-Header

Verwenden Sie diesen Ansatz für Szenarien, die mehr Kontrolle über HTTP-Anforderungen erfordern. Im folgenden Beispiel wird ein gebundener Autorisierungsheader erworben und ein mTLS-konfigurierter HTTP-Client erstellt.

using Microsoft.Identity.Abstractions;
using System.Net.Http.Headers;

public class CustomApiClient
{
    private readonly IAuthorizationHeaderProvider _authProvider;
    private readonly IHttpClientFactory _httpClientFactory;

    public CustomApiClient(
        IAuthorizationHeaderProvider authProvider,
        IHttpClientFactory httpClientFactory)
    {
        _authProvider = authProvider;
        _httpClientFactory = httpClientFactory;
    }

    public async Task<string> CallApiWithCustomLogicAsync()
    {
        // Create downstream API options for mTLS PoP
        var apiOptions = new DownstreamApiOptions
        {
            BaseUrl = "https://api.contoso.com",
            ProtocolScheme = "MTLS_POP",
            RequestAppToken = true,
            Scopes = new[] { "api://contoso/.default" }
        };

        // Get authorization header with binding certificate info
        var authResult = await (_authProvider as IBoundAuthorizationHeaderProvider)
            ?.CreateBoundAuthorizationHeaderAsync(apiOptions)!;

        if (authResult.IsSuccess)
        {
            // Create HTTP client with certificate binding
            var httpClient = authResult.Value.BindingCertificate != null
                ? CreateMtlsHttpClient(authResult.Value.BindingCertificate)
                : _httpClientFactory.CreateClient();

            // Set authorization header
            httpClient.DefaultRequestHeaders.Authorization =
                AuthenticationHeaderValue.Parse(authResult.Value.AuthorizationHeaderValue);

            // Make API call
            var response = await httpClient.GetAsync(
                $"{apiOptions.BaseUrl}/api/endpoint");

            return await response.Content.ReadAsStringAsync();
        }

        throw new InvalidOperationException("Failed to acquire token");
    }

    private HttpClient CreateMtlsHttpClient(X509Certificate2 certificate)
    {
        var handler = new HttpClientHandler();
        handler.ClientCertificates.Add(certificate);
        return new HttpClient(handler);
    }
}

Überprüfen der Tokenstruktur

Die folgenden Beispiele zeigen, wie standard- und gebundene Token unterschiedlich sind.

Vergleichen von OAuth2-Standardtoken

Ein OAuth2-Standardtoken enthält keine Zertifikatbindungsinformationen.

{
  "aud": "api://your-api",
  "iss": "https://login.microsoftonline.com/tenant-id/",
  "iat": 1234567890,
  "exp": 1234571490,
  "appid": "client-id",
  "tid": "tenant-id"
}

Überprüfen von mTLS-PoP-Token mit Bindung

Ein mTLS-PoP-Token enthält den cnf Anspruch, der das Token an ein bestimmtes Zertifikat bindet.

{
  "aud": "api://your-api",
  "iss": "https://login.microsoftonline.com/tenant-id/",
  "iat": 1234567890,
  "exp": 1234571490,
  "appid": "client-id",
  "tid": "tenant-id",
  "cnf": {
    "x5t#S256": "buc7x2HxS_hPnVJb9J5mwPr6jCw8Y_2LHDz-gp_-6KM"
  }
}

Der cnf Anspruch (Bestätigung) enthält den SHA-256-Fingerabdruck des Zertifikats, Base64Url-codiert.

Aktuelle Einschränkungen verstehen

Überprüfen Sie die folgenden Einschränkungen, bevor Sie die MTLS-PoP-Tokenbindung implementieren.

Nur Anwendungstoken unterstützen

Tokenbindung unterstützt derzeit nur Anwendungstoken (nur App-Token). Delegierte (Benutzer)-Token werden nicht unterstützt.

Festlegen des Protokollschemas

Die ProtocolScheme Eigenschaft muss explizit auf "MTLS_POP" festgelegt werden, um die Tokenbindung zu aktivieren. Wenn nicht festgelegt, wird die Standard-Bearer-Authentifizierung verwendet.

Erfüllen der Zertifikatanforderungen

Das Zertifikat muss in ClientCredentials mit SendX5c auf true konfiguriert werden.
Auf das Zertifikat muss zum Zeitpunkt des Tokenerwerbs zugegriffen werden kann.

Häufige Probleme beheben

Verwenden Sie die folgenden Anleitungen zum Diagnostizieren und Beheben von Tokenbindungsproblemen.

Allgemeine Probleme beheben

1. "Fehlender 'cnf'-Anspruch im Token"

Ursache: Die Tokenbindung wurde nicht ordnungsgemäß konfiguriert, oder das Token ist ein standardmäßiges Bearertoken.

Lösung: Stellen Sie sicher, dass ProtocolScheme auf "MTLS_POP" eingestellt ist und RequestAppTokentrue ist.

{
  "DownstreamApi": {
    "ProtocolScheme": "MTLS_POP",  // ensure this is set
    "RequestAppToken": true
  }
}

2. "Zertifikat-Fingerabdruck stimmt nicht überein"

Ursache: Das zertifikat, das der API angezeigt wird, stimmt nicht mit dem Zertifikat überein, das für den Tokenerwerb verwendet wird.

Lösung:

Überprüfen, ob dasselbe Zertifikat sowohl für Tokenerwerb als auch für API-Aufrufe verwendet wird
Überprüfen der Konfiguration des Ladens von Zertifikaten in ClientCredentials
Sicherstellen, dass das Zertifikat nicht abgelaufen oder erneuert ist

3. "Ein Zertifikat, das für die Tokenbindung erforderlich ist, fehlt"

Cause: In Microsoft Entra Einstellungen ist kein Zertifikat konfiguriert.

Lösung: Hinzufügen eines Zertifikats zu Ihrer ClientCredentials Konfiguration und Festlegen SendX5c auf true.

{
  "AzureAd": {
    "ClientCredentials": [
      {
        "SourceType": "StoreWithDistinguishedName",
        "CertificateStorePath": "CurrentUser/My",
        "CertificateDistinguishedName": "CN=YourCertificate"
      }
    ],
    "SendX5c": true  // required for token binding
  }
}

4. "Tokenbindung erfordert aktivierten App-Tokenerwerb"

Ursache: RequestAppToken ist nicht auf true.

Lösung: Setzen Sie RequestAppToken auf true in Ihren Optionen.

var options = new DownstreamApiOptions
{
    ProtocolScheme = "MTLS_POP",
    RequestAppToken = true,  // must be true
};

Debuggen der Tokenbindung

Verwenden Sie die folgenden Techniken, um Tokenbindungsprobleme zu untersuchen.

Aktivieren der detaillierten Protokollierung

Fügen Sie die folgende Konfiguration hinzu, um die Protokollierung auf Debug-Ebene für Microsoft.Identity.Web zu aktivieren.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.Identity.Web": "Debug"
    }
  }
}

Überprüfung von Tokenansprüchen

Verwenden Sie den folgenden Code, um alle Ansprüche in einem Token auflisten und nach dem cnf Anspruch zu suchen.

var handler = new JsonWebTokenHandler();
var token = handler.ReadJsonWebToken(tokenString);

foreach (var claim in token.Claims)
{
    Console.WriteLine($"{claim.Type}: {claim.Value}");
}

// Look for 'cnf' claim with x5t#S256
var cnfClaim = token.Claims.FirstOrDefault(c => c.Type == "cnf");

Überprüfen des Zertifikatfingerabdrucks

Verwenden Sie den folgenden Code, um den SHA-256-Fingerabdruck eines Zertifikats zum Vergleich zu berechnen und anzuzeigen.

using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using Microsoft.IdentityModel.Tokens;

var cert = new X509Certificate2("path/to/cert.pfx", "password");
using var sha256 = SHA256.Create();
var hash = sha256.ComputeHash(cert.RawData);
var thumbprint = Base64UrlEncoder.Encode(hash);
Console.WriteLine($"Certificate thumbprint: {thumbprint}");

Befolgen von Sicherheitsrichtlinien

Wenden Sie beim Implementieren der Tokenbindung die folgenden Sicherheitspraktiken an.

Sicheres Verwalten von Zertifikaten

Sicher speichern: Verwenden Sie Azure Key Vault oder sichere Zertifikatspeicher
Regelmäßige Erneuerung: Implementierung von Zertifikaterneuerungsverfahren
Ablauf überwachen: Einrichten von Warnungen für den Ablauf von Zertifikaten
Zugriff einschränken: Einschränken, wer auf private Zertifikatschlüssel zugreifen kann

Sichere Netzwerkverbindungen

TLS 1.2+ erforderlich: Sicherstellen, dass alle Verbindungen moderne TLS-Versionen verwenden
Überprüfen von Zertifikaten: Implementieren der richtigen Zertifikatüberprüfung auf dem Server
Verwenden von starken Verschlüsselungen: Konfigurieren sicherer Verschlüsselungssammlungen

Sicherer Umgang mit Tokens

Kurze Lebensdauer: Verwenden von kurzlebigen Token (empfohlen: 1 Stunde)
Richtiger Speicher: Token nie protokollieren oder verfügbar machen
Gründlich validieren: Überprüfen Sie alle Ansprüche, das Ablaufdatum und die Bindung

Bewährte Methoden befolgen

Beachten Sie beim Bereitstellen der MTLS-PoP-Tokenbindung die folgenden Empfehlungen.

Immer HTTPS verwenden: mTLS PoP erfordert einen sicheren Transport
Verwenden Sie ein Zertifikat, das das private Schlüsselmaterial in der Hardware speichert, z. B. in TPM: Verwenden von Hardware über Softwaresicherheit zum besseren Schutz
Implementieren einer ordnungsgemäßen Fehlerbehandlung: Behandeln von Zertifikat- und Tokenfehlern ordnungsgemäß
Überwachen des Ablaufs von Zertifikaten: Automatisieren der Zertifikatverlängerung
Verwenden von separaten Zertifikaten pro Umgebung: Dev-, Staging- und Produktionszertifikate
Protokollsicherheitsereignisse: Nachverfolgen von Tokenbindungsfehlern und Zertifikatkonflikten
Testen der Zertifikatrotation: Stellen Sie sicher, dass Ihre Anwendung Zertifikatupdates verarbeitet
Dokumentieren Sie Ihre Konfiguration: Bewahren Sie eine klare Dokumentation der Zertifikatanforderungen auf

Beispielcode erkunden

Vollständige Arbeitsbeispiele, in denen die MTLS-PoP-Tokenbindung veranschaulicht wird, sind im Repository verfügbar:

Clientanwendung: tests/DevApps/MtlsPop/MtlsPopClient
Web-API-Server: tests/DevApps/MtlsPop/MtlsPopWebApi

Diese Beispiele veranschaulichen:

Vollständige Client- und Serverkonfiguration
Tokenerwerb mit Zertifikatbindung
Implementierung eines benutzerdefinierten Authentifizierungshandlers
Zertifikatüberprüfung und Fingerabdrucküberprüfung

Feedback

War diese Seite hilfreich?

Last updated on 2026-04-29