Tokenbinding configureren met mTLS Proof-of-Possession (mTLS PoP)

Opmerking

Niet alle clients mogen mTLS PoP-certificaten verkrijgen omdat deze functie momenteel in de beperkte preview is.

Certificaattokenbinding (ook wel bekend als mTLS PoP - Mutual TLS Proof-of-Possession) is een geavanceerde beveiligingsfunctie waarmee cryptografisch toegangstokens worden gekoppeld aan een specifiek X.509-certificaat. RFC 8705 beschrijft deze binding. De binding zorgt ervoor dat zelfs als een token wordt onderschept, een aanvaller deze niet kan gebruiken zonder de bijbehorende persoonlijke sleutel te hebben.

Begrijpen hoe tokenbinding werkt

In de volgende stappen wordt de bindingstroom van het token beschreven van overname via verificatie.

Tokenverwerving: bij het aanvragen van een toegangstoken waarvoor tokenbinding is ingeschakeld, bevat Microsoft Identity Web de vingerafdruk van het certificaat in de tokenaanvraag
Tokenbinding: De autorisatieserver sluit een cnf (bevestigings)claim in het uitgegeven token in met de SHA-256-vingerafdruk van het certificaat (x5t#S256)
API-aanroep: de client geeft zowel het afhankelijke token als het certificaat weer bij het aanroepen van de downstream-API
Verificatie: De API valideert dat het gepresenteerde certificaat overeenkomt met de certificaatreferentie in de claim van cnf het token

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

Beveiligingsvoordelen bekijken

Tokenbinding biedt de volgende voordelen voor het beveiligen van uw toepassingen.

Beveiliging tegen tokendiefstal: gestolen tokens zijn nutteloos zonder het bijbehorende certificaat
Aanvalspreventie opnieuw afspelen: tokens kunnen niet opnieuw worden afgespeeld vanaf verschillende clients
Verbeterde verificatie: combineert 'iets wat u hebt' (certificaat) met traditionele OAuth2-stromen
Zero Trust Architectuur: is consistent met Zero Trust-principes door inloggegevens aan specifieke apparaten te koppelen

Tokenbinding configureren

Stel zowel de clienttoepassing als de API-server in om mTLS PoP-tokenbinding in te schakelen.

De clienttoepassing configureren

Voer de volgende stappen uit om de clienttoepassing voor tokenbinding te configureren.

1. Microsoft Entra ID-instellingen configureren

Configureer in uw appsettings.json uw Microsoft Entra instellingen, waaronder het certificaat:

{
  "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. Downstream-API configureren met tokenbinding

Configureer de downstream-API-sectie met het MTLS_POP protocolschema:

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

Belangrijke configuratie-eigenschappen:

ProtocolScheme: moet zijn ingesteld op "MTLS_POP" om tokenbinding in te schakelen
RequestAppToken: Moet zijn true (tokenbinding ondersteunt momenteel alleen toepassingstokens)
Scopes: API-bereiken vereist voor de downstream-API-aanroep

3. Services registreren

Registreer de downstream-API-service in de opstartcode van uw toepassing. In het volgende voorbeeld ziet u zowel de console-app als ASP.NET Core benaderingen.

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

De API-server configureren

De downstream-API moet zowel het token als de certificaatbinding valideren. Hier volgt een volledig voorbeeld:

1. Verificatie-handlers registreren

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. MTLS PoP-verificatiehandler implementeren

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

Tokenbinding gebruiken in toepassingen

In de volgende voorbeelden ziet u hoe u mTLS PoP-tokenbinding integreert in verschillende toepassingstypen.

API's aanroepen vanuit een console- of daemon-toepassing

In het volgende voorbeeld ziet u een console- of daemon-toepassing die een downstream-API aanroept met mTLS PoP-tokenbinding.

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

API's aanroepen vanuit een ASP.NET Core-webtoepassing

In het volgende voorbeeld ziet u een controller die een downstream-API aanroept met mTLS PoP-tokenbinding.

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

DownstreamApiOptions programmatisch configureren

In het volgende voorbeeld worden mTLS PoP-opties rechtstreeks in code ingesteld in plaats van configuratiebestanden.

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

MicrosoftIdentityMessageHandler gebruiken met tokenbinding

MicrosoftIdentityMessageHandler ondersteunt mTLS PoP-tokenbinding via de AddMicrosoftIdentityMessageHandler extensiemethoden. Wanneer ProtocolScheme is ingesteld op "MTLS_POP", verkrijgt de handler automatisch een bound token en verzendt deze aanvragen via een mTLS-geconfigureerde HTTP-client.

Inlineopties configureren

In het volgende voorbeeld wordt een HTTP-client geregistreerd met een inline mTLS PoP-configuratie en wordt het gebruik ervan in een service weergegeven.

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

Configuratie laden vanuit appsettings.json

U kunt ook instellingen voor tokenbinding laden vanuit uw configuratiebestand.

appsettings.json:

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

Program.cs: Met de volgende code wordt de HTTP-client geregistreerd met behulp van de configuratiesectie.

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

Tokenbinding per aanvraag toepassen

Gebruik opties per aanvraag wanneer sommige aanvragen tokenbinding nodig hebben en andere niet:

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

Zie de documentatie over MicrosoftIdentityMessageHandleraangepaste API's voor meer informatie.

Een aangepaste HttpClient maken met autorisatieheaderprovider

Gebruik deze methode voor scenario's waarvoor meer controle nodig is over HTTP-aanvragen. In het volgende voorbeeld wordt een afhankelijke autorisatieheader verkregen en wordt een door mTLS geconfigureerde HTTP-client gemaakt.

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

Tokenstructuur onderzoeken

In de volgende voorbeelden ziet u hoe standaard- en afhankelijke tokens verschillen.

Standaard OAuth2-tokens vergelijken

Een standaard OAuth2-token bevat geen certificaatbindingsinformatie.

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

MTLS PoP-tokens met binding controleren

Een mTLS PoP-token bevat de cnf claim die het token verbindt met een specifiek certificaat.

{
  "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"
  }
}

De cnf claim (bevestiging) bevat de SHA-256-vingerafdruk van het certificaat, Base64Url-gecodeerd.

Inzicht in bestaande beperkingen

Bekijk de volgende beperkingen voordat u mTLS PoP-tokenbinding implementeert.

Alleen toepassingstokens ondersteunen

Tokenbinding ondersteunt momenteel alleen toepassingstokens (alleen voor apps). Gedelegeerde tokens (gebruikers) worden niet ondersteund.

Het protocolschema instellen

De eigenschap ProtocolScheme moet expliciet worden ingesteld op "MTLS_POP" om tokenbinding in te schakelen. Als dit niet is ingesteld, wordt standaard Bearer-verificatie gebruikt.

Voldoen aan certificaatvereisten

Het certificaat moet in ClientCredentials zijn geconfigureerd met SendX5c ingesteld op true
Het certificaat moet toegankelijk zijn tijdens het ophalen van tokens

Veelvoorkomende problemen oplossen

Gebruik de volgende richtlijnen om bindingsproblemen met tokens vast te stellen en op te lossen.

Algemene problemen oplossen

1. "Ontbrekende 'cnf'-claim in token"

Oorzaak: Tokenbinding is niet juist geconfigureerd of het token is een standaard Bearer-token.

Oplossing: Controleer of ProtocolScheme is ingesteld op "MTLS_POP" en RequestAppToken is true.

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

2. "Vingerafdruk van certificaat komt niet overeen"

Oorzaak: het certificaat dat aan de API wordt gepresenteerd, komt niet overeen met het certificaat dat wordt gebruikt voor het ophalen van tokens.

Solution:

Controleer of hetzelfde certificaat wordt gebruikt voor het verkrijgen van tokens en API-aanroepen
De configuratie voor het laden van certificaten controleren in ClientCredentials
Controleren of het certificaat niet is verlopen of vernieuwd

3. Er ontbreekt een certificaat dat is vereist voor tokenbinding

Cause: Er is geen certificaat geconfigureerd in Microsoft Entra instellingen.

Oplossing: Voeg een certificaat toe aan uw ClientCredentials configuratie en stel deze in op SendX5ctrue.

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

4. Tokenbinding vereist ingeschakelde app-tokenverwerving

Oorzaak: RequestAppToken is niet ingesteld op true.

Oplossing: Stel RequestAppToken in op true in je opties.

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

Tokenbinding voor foutopsporing

Gebruik de volgende technieken om tokenbindingsproblemen te onderzoeken.

Gedetailleerde logboekregistratie inschakelen

Voeg de volgende configuratie toe om logboekregistratie op foutopsporingsniveau in te schakelen voor Microsoft. Identity.Web.

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

Tokenclaims controleren

Gebruik de volgende code om alle claims in een token weer te geven en te controleren op de cnf claim.

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

Vingerafdruk van certificaat controleren

Gebruik de volgende code om de SHA-256-vingerafdruk van een certificaat te berekenen en weer te geven ter vergelijking.

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

Beveiligingsrichtlijnen volgen

Pas de volgende beveiligingsprocedures toe wanneer u tokenbinding implementeert.

Certificaten veilig beheren

Store veilig: gebruik Azure Key Vault of beveiligde certificaatarchieven
Regelmatig vervangen: Procedures voor certificaatrotatie implementeren
Verlooptijd bewaken: waarschuwingen instellen voor het verlopen van certificaten
Toegang beperken: beperken wie toegang heeft tot persoonlijke certificaatsleutels

Netwerkverbindingen beveiligen

TLS 1.2+vereisen: zorg ervoor dat alle verbindingen moderne TLS-versies gebruiken
Certificaten valideren: de juiste certificaatvalidatie implementeren op de server
Sterke coderingen gebruiken: Veilige coderingssuites configureren

Tokens veilig verwerken

Korte levensduur: gebruik tokens met korte levensduur (aanbevolen: 1 uur)
Juiste opslag: nooit tokens registreren of beschikbaar maken
Valideer grondig: Controleer alle claims, vervaldatum en binding

Best practices volgen

Houd rekening met de volgende aanbevelingen wanneer u mTLS PoP-tokenbinding implementeert.

Altijd HTTPS gebruiken: mTLS PoP vereist veilig transport
Gebruik een certificaat waarin het materiaal van de persoonlijke sleutel wordt opgeslagen in hardware, bijvoorbeeld in TPM: hardware gebruiken via softwarebeveiliging voor betere beveiliging
De juiste foutafhandeling implementeren: certificaat- en tokenfouten probleemloos verwerken
Vervaldatum van certificaat bewaken: Certificaatvernieuwing automatiseren
Afzonderlijke certificaten per omgeving gebruiken: dev-, faserings- en productiecertificaten
Beveiligingslogboeken: token-bindingsfouten bijhouden en certificaatverschillen
Certificaatrotatie testen: Zorg ervoor dat uw toepassing certificaatupdates verwerkt
Documenteer uw configuratie: duidelijke documentatie over certificaatvereisten behouden

Voorbeeldcode verkennen

Volledige werkvoorbeelden waarin mTLS PoP-tokenbinding wordt gedemonstreerd, zijn beschikbaar in de opslagplaats:

Clientapplicatie: tests/DevApps/MtlsPop/MtlsPopClient
Web-API-server: tests/DevApps/MtlsPop/MtlsPopWebApi

Deze voorbeelden laten zien:

Volledige client- en serverconfiguratie
Token ophalen met certificaatbinding
Implementatie van aangepaste verificatiehandler
Certificaatvalidatie en verificatie van vingerafdruk

Feedback

Is deze pagina nuttig?

Last updated on 2026-04-29