Konfigurowanie powiązania tokenu za pomocą narzędzia mTLS Proof-of-Possession (mTLS PoP)

Note

Nie wszyscy klienci mogą uzyskiwać certyfikaty mTLS PoP, ponieważ ta funkcja jest obecnie w prywatnej wersji zapoznawczej.

Powiązanie tokenu certyfikatu (nazywane również mTLS PoP — wzajemny dowód posiadania protokołu TLS) to zaawansowana funkcja zabezpieczeń, która kryptograficznie wiąże tokeny dostępu z określonym certyfikatem X.509. RFC 8705 opisuje to powiązanie. Powiązanie gwarantuje, że nawet w przypadku przechwycenia tokenu osoba atakująca nie może jej używać bez posiadania odpowiedniego klucza prywatnego.

Zrozumienie, jak działa wiązanie tokenu

W poniższych krokach opisano przepływ powiązania tokenu od pozyskania do weryfikacji.

Token Acquisition: Podczas żądania tokenu z włączonym wiązaniem tokenu Microsoft Identity Web dołącza odcisk palca certyfikatu do żądania tokenu
Powiązanie tokenu: serwer autoryzacji umieszcza oświadczenie (potwierdzenie) w wystawionym tokenie, który zawiera odcisk palca SHA-256 certyfikatu (cnf)
Wywołanie interfejsu API: klient przedstawia zarówno token powiązany, jak i certyfikat podczas wywoływania podrzędnego interfejsu API
Weryfikacja: interfejs API sprawdza, czy przedstawiony certyfikat jest zgodny z odwołaniem do certyfikatu w oświadczeniu tokenu cnf

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

Przegląd korzyści zabezpieczeń

Powiązanie tokenu zapewnia następujące korzyści w zakresie zabezpieczania aplikacji.

Ochrona przed kradzieżą tokenów: skradzione tokeny są bezużyteczne bez odpowiedniego certyfikatu
Zapobieganie atakom powtarzanym: tokeny nie mogą być odtwarzane z różnych klientów
Rozszerzone uwierzytelnianie: łączy "coś, co masz" (certyfikat) z tradycyjnymi przepływami OAuth2
architektura Zero Trust: jest zgodna z zasadami zero trust przez powiązanie poświadczeń z określonymi urządzeniami

Konfigurowanie powiązania tokenu

Skonfiguruj zarówno aplikację klienckę, jak i serwer interfejsu API, aby włączyć powiązanie tokenu mTLS PoP.

Konfigurowanie aplikacji klienckiej

Wykonaj poniższe kroki, aby skonfigurować aplikację kliencka na potrzeby powiązania tokenu.

1. Konfigurowanie ustawień Microsoft Entra ID

W appsettings.json skonfiguruj ustawienia Microsoft Entra, w tym certyfikat:

{
  "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. Konfigurowanie podrzędnego interfejsu API przy użyciu powiązania tokenu

Skonfiguruj sekcję podrzędnego interfejsu API za pomocą schematu MTLS_POP protokołu:

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

Ważne właściwości konfiguracji:

ProtocolScheme: Musi być ustawiona na wartość "MTLS_POP", aby włączyć powiązanie tokenu
RequestAppToken: Musi być true (powiązanie tokenu obecnie obsługuje tylko tokeny aplikacji)
Scopes: zakresy interfejsu API wymagane do wywołania podrzędnego interfejsu API

3. Rejestrowanie usług

Zarejestruj usługę podrzędnego interfejsu API w kodzie uruchamiania aplikacji. W poniższym przykładzie przedstawiono metody zarówno aplikacji konsolowej, jak i ASP.NET Core.

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

Konfigurowanie serwera interfejsu API

Interfejs API podrzędny musi zweryfikować zarówno token, jak i powiązanie certyfikatu. Oto kompletny przykład:

1. Rejestrowanie procedur obsługi uwierzytelniania

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. Implementowanie programu obsługi uwierzytelniania mTLS PoP

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

Używanie powiązania tokenu w aplikacjach

W poniższych przykładach pokazano, jak zintegrować powiązanie tokenu mTLS PoP w różnych typach aplikacji.

Wywoływanie interfejsów API z poziomu konsoli lub aplikacji demona

W poniższym przykładzie pokazano aplikację konsolową lub demona, która wywołuje API niższego rzędu z powiązaniem tokenu mTLS PoP.

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

Wywoływanie interfejsów API z aplikacji internetowej ASP.NET Core

Na poniższym przykładzie pokazano sterownik, który wywołuje interfejs API znajdujący się niżej w hierarchii z powiązaniem tokenu mTLS PoP.

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

Konfigurowanie opcji DownstreamApiOptions w sposób programowy

Poniższy przykład ustawia opcje poP biblioteki mTLS bezpośrednio w kodzie zamiast plików konfiguracji.

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

Używanie programu MicrosoftIdentityMessageHandler z powiązaniem tokenu

MicrosoftIdentityMessageHandler obsługuje powiązanie tokenu mTLS PoP za pomocą metod rozszerzenia AddMicrosoftIdentityMessageHandler. Gdy ProtocolScheme jest ustawiona wartość "MTLS_POP", program obsługi automatycznie uzyskuje powiązany token i wysyła żądania za pośrednictwem klienta HTTP skonfigurowanego przez usługę mTLS.

Konfigurowanie opcji wbudowanych

W poniższym przykładzie zarejestrowano klienta HTTP z konfiguracją mTLS PoP w linii i pokazano jego użycie w usłudze.

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

Ładowanie konfiguracji z appsettings.json

Możesz również załadować ustawienia powiązania tokenu z pliku konfiguracji.

appsettings.json:

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

Program.cs: Następujący kod rejestruje klienta HTTP przy użyciu sekcji konfiguracji.

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

Zastosuj wiązanie tokenów na żądanie

Używaj opcji specyficznych dla żądań, gdy niektóre z nich wymagają powiązania tokenu, a inne nie.

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

Aby uzyskać więcej informacji na temat MicrosoftIdentityMessageHandler, zobacz dokumentację interfejsów API niestandardowych.

Tworzenie niestandardowego HttpClient z dostawcą nagłówków autoryzacji

Użyj tego podejścia w scenariuszach wymagających większej kontroli nad żądaniami HTTP. Poniższy przykład uzyskuje nagłówek związanej autoryzacji i tworzy klienta HTTP skonfigurowanego dla mTLS.

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

Sprawdzanie struktury tokenu

W poniższych przykładach pokazano, jak różnią się tokeny standardowe i powiązane.

Porównanie standardowych tokenów OAuth2

Standardowy token OAuth2 nie zawiera informacji o powiązaniu certyfikatu.

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

Przeglądanie tokenów mTLS PoP z powiązaniem

Token mTLS PoP zawiera cnf oświadczenie, które wiąże token z określonym certyfikatem.

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

Oświadczenie cnf (potwierdzenie) zawiera odcisk palca SHA-256 certyfikatu zakodowany w formacie Base64Url.

Zrozum bieżące ograniczenia

Przed wdrożeniem powiązania tokenu mTLS PoP zapoznaj się z poniższymi ograniczeniami.

Obsługa tylko tokenów aplikacji

Powiązanie tokenu obsługuje obecnie tylko tokeny aplikacji (tylko dla aplikacji). Tokeny delegowane (użytkownika) nie są obsługiwane.

Ustawianie schematu protokołu

Właściwość ProtocolScheme musi być jawnie ustawiona na "MTLS_POP", aby włączyć powiązanie tokenu. Jeśli nie zostanie ustawiona, zostanie użyte standardowe uwierzytelnianie elementu nośnego.

Spełnianie wymagań dotyczących certyfikatów

Certyfikat musi być skonfigurowany w ClientCredentials z ustawioną wartością SendX5c na true
Certyfikat musi być dostępny w czasie pozyskiwania tokenu

Rozwiązywanie typowych problemów

Skorzystaj z poniższych wskazówek, aby zdiagnozować i rozwiązać problemy z powiązaniem tokenu.

Rozwiązywanie typowych problemów

Brak deklaracji "cnf" w tokenie

Przyczyna: Powiązanie tokenu nie zostało prawidłowo skonfigurowane lub token jest standardowym tokenem elementu nośnego.

Rozwiązanie: Sprawdź, czy ProtocolScheme jest ustawiony na "MTLS_POP" i RequestAppToken to true.

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

2. "Niezgodność odcisku palca certyfikatu"

Przyczyna: Certyfikat przedstawiony interfejsowi API jest niezgodny z certyfikatem używanym do pozyskiwania tokenu.

Rozwiązanie:

Sprawdź, czy ten sam certyfikat jest używany na potrzeby pozyskiwania tokenów i wywołań interfejsu API
Sprawdź konfigurację ładowania certyfikatu w ClientCredentials
Upewnij się, że certyfikat nie wygasł lub został odnowiony

3. Brak certyfikatu wymaganego do powiązania tokenu"

Cause: w ustawieniach Microsoft Entra nie skonfigurowano żadnego certyfikatu.

Rozwiązanie: Dodaj certyfikat do ClientCredentials konfiguracji i ustaw SendX5c na true.

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

4. "Powiązanie tokenu wymaga włączenia pozyskiwania tokenu aplikacji"

Przyczyna: RequestAppToken nie jest ustawiona na true.

Rozwiązanie: ustaw wartość RequestAppToken na true w opcjach.

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

Debugowanie powiązania tokenu

Skorzystaj z poniższych technik, aby zbadać problemy z powiązaniem tokenu.

Włącz szczegółowe rejestrowanie

Dodaj następującą konfigurację, aby włączyć rejestrowanie na poziomie debugowania dla Microsoft. Identity.Web.

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

Sprawdzenie żądań tokenu

Użyj poniższego kodu, aby wyświetlić wszystkie roszczenia w tokenie i sprawdzić roszczenie cnf.

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

Weryfikowanie odcisku palca certyfikatu

Użyj poniższego kodu, aby obliczyć i wyświetlić odcisk palca SHA-256 certyfikatu na potrzeby porównania.

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

Postępuj zgodnie z wytycznymi dotyczącymi zabezpieczeń

Zastosuj następujące rozwiązania w zakresie zabezpieczeń podczas implementowania powiązania tokenu.

Bezpieczne zarządzanie certyfikatami

Store bezpiecznie: użyj Azure Key Vault lub zabezpieczonych magazynów certyfikatów
Regularnie obracaj: Implementuj procedury rotacji certyfikatów
Wygaśnięcie monitora: konfigurowanie alertów dotyczących wygasania certyfikatu
Ograniczanie dostępu: Ogranicz, kto może uzyskać dostęp do kluczy prywatnych certyfikatów

Zabezpieczanie połączeń sieciowych

Wymagaj protokołu TLS 1.2+: Upewnij się, że wszystkie połączenia korzystają z nowoczesnych wersji protokołu TLS
Weryfikowanie certyfikatów: Implementowanie prawidłowej weryfikacji certyfikatu na serwerze
Używanie silnych szyfrów: Konfigurowanie bezpiecznych zestawów szyfrowania

Bezpieczne obsługa tokenów

Krótkie okresy istnienia: użyj tokenów krótkotrwałych (zalecane: 1 godzina)
Prawidłowe przechowywanie: nigdy nie rejestruj ani nie ujawniaj tokenów
Dokładnie zweryfikuj: Sprawdź wszystkie roszczenia, wiązanie i wygaśnięcie

Postępuj zgodnie z najlepszymi rozwiązaniami

Podczas wdrażania powiązania tokenu mTLS PoP należy pamiętać o poniższych zaleceniach.

Zawsze używaj protokołu HTTPS: mTLS PoP wymaga bezpiecznego transportu
Użyj certyfikatu, który przechowuje materiał klucza prywatnego na sprzęcie, np. w module TPM: używaj sprzętu za pośrednictwem zabezpieczeń oprogramowania w celu zapewnienia lepszej ochrony
Implementowanie prawidłowej obsługi błędów: Gracefully handle certificate and token errors (Implementowanie prawidłowej obsługi błędów: obsługa certyfikatu i błędów tokenu)
Monitorowanie wygaśnięcia certyfikatu: Automatyzowanie odnawiania certyfikatu
Używaj oddzielnych certyfikatów dla każdego środowiska: certyfikaty deweloperskie, testowe i produkcyjne
Rejestruj zdarzenia zabezpieczeń: Śledź błędy powiązań tokenów i niezgodności certyfikatów
Rotacja certyfikatów testowych: upewnij się, że aplikacja obsługuje aktualizacje certyfikatów
Dokumentowanie konfiguracji: zachowaj czytelną dokumentację wymagań dotyczących certyfikatów

Eksplorowanie przykładowego kodu

Kompletne przykłady robocze przedstawiające powiązanie tokenu mTLS PoP są dostępne w repozytorium:

Aplikacja kliencka: tests/DevApps/MtlsPop/MtlsPopClient
Serwer internetowego interfejsu API: tests/DevApps/MtlsPop/MtlsPopWebApi

Te przykłady pokazują:

Ukończ konfigurację klienta i serwera
Pozyskiwanie tokenu za pomocą powiązania certyfikatu
Implementacja niestandardowej procedury obsługi uwierzytelniania
Weryfikacja certyfikatu i weryfikacja odcisku palca

Opinia

Czy ta strona była pomocna?

Last updated on 2026-04-29

Konfigurowanie powiązania tokenu za pomocą narzędzia mTLS Proof-of-Possession (mTLS PoP)

Zrozumienie, jak działa wiązanie tokenu

Przegląd korzyści zabezpieczeń

Konfigurowanie powiązania tokenu

Konfigurowanie aplikacji klienckiej

1. Konfigurowanie ustawień Microsoft Entra ID

2. Konfigurowanie podrzędnego interfejsu API przy użyciu powiązania tokenu

3. Rejestrowanie usług

Konfigurowanie serwera interfejsu API

1. Rejestrowanie procedur obsługi uwierzytelniania

2. Implementowanie programu obsługi uwierzytelniania mTLS PoP

Używanie powiązania tokenu w aplikacjach

Wywoływanie interfejsów API z poziomu konsoli lub aplikacji demona

Wywoływanie interfejsów API z aplikacji internetowej ASP.NET Core

Konfigurowanie opcji DownstreamApiOptions w sposób programowy

Używanie programu MicrosoftIdentityMessageHandler z powiązaniem tokenu

Konfigurowanie opcji wbudowanych

Ładowanie konfiguracji z appsettings.json

Zastosuj wiązanie tokenów na żądanie

Tworzenie niestandardowego HttpClient z dostawcą nagłówków autoryzacji

Sprawdzanie struktury tokenu

Porównanie standardowych tokenów OAuth2

Przeglądanie tokenów mTLS PoP z powiązaniem

Zrozum bieżące ograniczenia

Obsługa tylko tokenów aplikacji

Ustawianie schematu protokołu

Spełnianie wymagań dotyczących certyfikatów

Rozwiązywanie typowych problemów

Rozwiązywanie typowych problemów

Brak deklaracji "cnf" w tokenie

2. "Niezgodność odcisku palca certyfikatu"

3. Brak certyfikatu wymaganego do powiązania tokenu"

4. "Powiązanie tokenu wymaga włączenia pozyskiwania tokenu aplikacji"

Debugowanie powiązania tokenu

Włącz szczegółowe rejestrowanie

Sprawdzenie żądań tokenu

Weryfikowanie odcisku palca certyfikatu

Postępuj zgodnie z wytycznymi dotyczącymi zabezpieczeń

Bezpieczne zarządzanie certyfikatami

Zabezpieczanie połączeń sieciowych

Bezpieczne obsługa tokenów

Postępuj zgodnie z najlepszymi rozwiązaniami

Treści powiązane

Eksplorowanie przykładowego kodu

Opinia

Dodatkowe zasoby