Enable mTLS Proof‑of‑Possession for Client‑Assertion Delegates

src/client/Microsoft.Identity.Client/ApiConfig/AcquireTokenForClientParameterBuilder.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
 using System;
@@ -15,6 +15,7 @@
 using Microsoft.Identity.Client.Utils;
 using Microsoft.Identity.Client.Extensibility;
 using Microsoft.Identity.Client.OAuth2;
+using System.Security.Cryptography.X509Certificates;
 
 namespace Microsoft.Identity.Client
 {
@@ -96,18 +97,19 @@ public AcquireTokenForClientParameterBuilder WithSendX5C(bool withSendX5C)
         /// <returns>The current instance of <see cref="AcquireTokenForClientParameterBuilder"/> to enable method chaining.</returns>
         public AcquireTokenForClientParameterBuilder WithMtlsProofOfPossession()
         {
-            if (ServiceBundle.Config.ClientCredential is not CertificateClientCredential certificateCredential)
+            if (ServiceBundle.Config.ClientCredential is CertificateClientCredential certificateCredential)
             {
-                throw new MsalClientException(
+                if (certificateCredential.Certificate == null)
+                {
+                    throw new MsalClientException(
                     MsalError.MtlsCertificateNotProvided,
                     MsalErrorMessage.MtlsCertificateNotProvidedMessage);
-            }
-            else
-            {
+                }
+
                 CommonParameters.AuthenticationOperation = new MtlsPopAuthenticationOperation(certificateCredential.Certificate);
-                CommonParameters.MtlsCertificate = certificateCredential.Certificate;
+                CommonParameters.MtlsCertificate = certificateCredential.Certificate;               
             }
-
+            CommonParameters.IsMtlsPopEnabled = true;
             return this;
         }
 

src/client/Microsoft.Identity.Client/ApiConfig/Executors/ConfidentialClientExecutor.cs

@@ -2,12 +2,15 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Identity.Client.ApiConfig.Parameters;
 using Microsoft.Identity.Client.AuthScheme.PoP;
 using Microsoft.Identity.Client.Instance.Discovery;
+using Microsoft.Identity.Client.Instance.Validation;
 using Microsoft.Identity.Client.Internal;
+using Microsoft.Identity.Client.Internal.ClientCredential;
 using Microsoft.Identity.Client.Internal.Requests;
 using Microsoft.Identity.Client.ManagedIdentity;
 using Microsoft.Identity.Client.Utils;
@@ -55,6 +58,9 @@ public async Task<AuthenticationResult> ExecuteAsync(
             AcquireTokenForClientParameters clientParameters,
             CancellationToken cancellationToken)
         {
+            await PopBindingResolver.ValidateAndWireAsync(ServiceBundle, commonParameters,cancellationToken)
+                .ConfigureAwait(false);
+
             RequestContext requestContext = CreateRequestContextAndLogVersionInfo(commonParameters.CorrelationId, commonParameters.MtlsCertificate, cancellationToken);
 
             AuthenticationRequestParameters requestParams = await _confidentialClientApplication.CreateRequestParametersAsync(

src/client/Microsoft.Identity.Client/ApiConfig/Parameters/AcquireTokenCommonParameters.cs

@@ -33,5 +33,6 @@ internal class AcquireTokenCommonParameters
         public SortedList<string, string> CacheKeyComponents { get; internal set; }
         public string FmiPathSuffix { get; internal set; }
         public string ClientAssertionFmiPath { get; internal set; }
+        public bool IsMtlsPopEnabled { get; set; }
     }
 }

src/client/Microsoft.Identity.Client/AppConfig/ClientAssertion.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Security.Cryptography.X509Certificates;
+
+namespace Microsoft.Identity.Client
+{
+    /// <summary>
+    /// Container returned from <c>WithClientAssertion</c>.
+    /// </summary>
+    public class ClientAssertion
+    {
+        /// <summary>
+        /// Represents the client assertion (JWT) and optional mutual‑TLS binding certificate returned
+        /// by the <c>clientAssertionProvider</c> callback supplied to
+        /// <see cref="ConfidentialClientApplicationBuilder.WithClientAssertion(System.Func{AssertionRequestOptions, System.Threading.CancellationToken, System.Threading.Tasks.Task{ClientAssertion}})"/>.
+        /// </summary>
+        /// <remarks>
+        /// MSAL forwards <see cref="Assertion"/> to the token endpoint as the <c>client_assertion</c> parameter.
+        /// When mutual‑TLS Proof‑of‑Possession (PoP) is enabled on the application and a
+        /// <see cref="TokenBindingCertificate"/> is provided, MSAL sets <c>client_assertion_type</c> to
+        /// <c>urn:ietf:params:oauth:client-assertion-type:jwt-pop</c>; otherwise it uses <c>jwt-bearer</c>.
+        /// <br/><br/>
+        /// Guidance on constructing the client assertion (required claims, audience, and lifetime) is available at
+        /// <see href="https://aka.ms/msal-net-client-assertion">aka.ms/msal-net-client-assertion</see>.
+        /// The assertion is created by your callback; MSAL does not modify or re‑sign it.
+        /// </remarks>
+        public string Assertion { get; set; }
+
+        /// <summary>
+        /// Optional. Certificate used to bind the client assertion for mutual‑TLS Proof‑of‑Possession (PoP).
+        /// </summary>
+        /// <remarks>
+        /// Provide a value only when PoP is enabled on the application. The certificate should include an
+        /// accessible private key. If <c>null</c>, MSAL treats the assertion as a bearer assertion and uses
+        /// <c>client_assertion_type=jwt-bearer</c>.
+        /// </remarks>
+        public X509Certificate2 TokenBindingCertificate { get; set; }
+    }
+}

src/client/Microsoft.Identity.Client/AppConfig/ConfidentialClientApplicationBuilder.cs

@@ -228,13 +228,12 @@ public ConfidentialClientApplicationBuilder WithClientAssertion(Func<string> cli
                 throw new ArgumentNullException(nameof(clientAssertionDelegate));
             }
 
-            Func<CancellationToken, Task<string>> clientAssertionAsyncDelegate = (_) =>
-            {
-                return Task.FromResult(clientAssertionDelegate());
-            };
-
-            Config.ClientCredential = new SignedAssertionDelegateClientCredential(clientAssertionAsyncDelegate);
-            return this;
+            return WithClientAssertion(
+                (opts, ct) =>
+                    Task.FromResult(new ClientAssertion
+                    {
+                        Assertion = clientAssertionDelegate()   // bearer
+                    }));
         }
 
         /// <summary>
@@ -252,8 +251,12 @@ public ConfidentialClientApplicationBuilder WithClientAssertion(Func<Cancellatio
                 throw new ArgumentNullException(nameof(clientAssertionAsyncDelegate));
             }
 
-            Config.ClientCredential = new SignedAssertionDelegateClientCredential(clientAssertionAsyncDelegate);
-            return this;
+            return WithClientAssertion(
+                async (opts, ct) =>
+                {
+                    string jwt = await clientAssertionAsyncDelegate(ct).ConfigureAwait(false);
+                    return new ClientAssertion { Assertion = jwt };    // bearer
+                });
         }
 
         /// <summary>
@@ -270,7 +273,30 @@ public ConfidentialClientApplicationBuilder WithClientAssertion(Func<AssertionRe
                 throw new ArgumentNullException(nameof(clientAssertionAsyncDelegate));
             }
 
-            Config.ClientCredential = new SignedAssertionDelegateClientCredential(clientAssertionAsyncDelegate);
+            return WithClientAssertion(
+                async (opts, _) =>
+                {
+                    string jwt = await clientAssertionAsyncDelegate(opts).ConfigureAwait(false);
+                    return new ClientAssertion { Assertion = jwt };    // bearer
+                });
+        }
+
+        /// <summary>
+        /// Configures the client application to use a client assertion for authentication.
+        /// </summary>
+        /// <remarks>This method allows the client application to authenticate using a custom client
+        /// assertion, which can be useful in scenarios where the assertion needs to be dynamically generated or
+        /// retrieved.</remarks>
+        /// <param name="clientAssertionProvider">A delegate that asynchronously provides an <see cref="ClientAssertion"/> based on the given <see
+        /// cref="AssertionRequestOptions"/> and <see cref="CancellationToken"/>. This delegate must not be <see
+        /// langword="null"/>.</param>
+        /// <returns>The <see cref="ConfidentialClientApplicationBuilder"/> instance configured with the specified client
+        /// assertion.</returns>
+        /// <exception cref="MsalClientException">Thrown if <paramref name="clientAssertionProvider"/> is <see langword="null"/>.</exception>
+        public ConfidentialClientApplicationBuilder WithClientAssertion(Func<AssertionRequestOptions,
+            CancellationToken, Task<ClientAssertion>> clientAssertionProvider)
+        {
+            Config.ClientCredential = new ClientAssertionDelegateCredential(clientAssertionProvider);
             return this;
         }
 

src/client/Microsoft.Identity.Client/AuthScheme/PoP/PopBindingResolver.cs

@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Identity.Client.ApiConfig.Parameters;
+using Microsoft.Identity.Client.AuthScheme.PoP;
+using Microsoft.Identity.Client.Internal;
+using Microsoft.Identity.Client.Internal.ClientCredential;
+using Microsoft.Identity.Client.Internal.Requests;
+
+namespace Microsoft.Identity.Client.AuthScheme.PoP
+{
+    /// <summary>
+    /// Central place for validating mTLS Proof‑of‑Possession pre‑conditions
+    /// and wiring up <see cref="MtlsPopAuthenticationOperation"/>.
+    /// </summary>
+    internal static class PopBindingResolver
+    {
+        /// <summary>
+        /// Ensures a certificate is available, region settings are correct,
+        /// and populates <see cref="AcquireTokenCommonParameters.AuthenticationOperation"/>
+        /// and <see cref="AcquireTokenCommonParameters.MtlsCertificate"/>.
+        /// </summary>
+        internal static async Task ValidateAndWireAsync(IServiceBundle serviceBundle,
+            AcquireTokenCommonParameters commonParameters,
+            CancellationToken ct)
+        {
+            if (!commonParameters.IsMtlsPopEnabled)
+            {
+                return; // PoP not requested
+            }
+
+            // ────────────────────────────────────
+            // Case 1 – Certificate credential
+            // ────────────────────────────────────
+            if (serviceBundle.Config.ClientCredential is CertificateClientCredential certCred)
+            {
+                if (certCred.Certificate == null)
+                {
+                    throw new MsalClientException(
+                        MsalError.MtlsCertificateNotProvided,
+                        MsalErrorMessage.MtlsCertificateNotProvidedMessage);
+                }
+
+                return;
+            }
+
+            // ────────────────────────────────────
+            // Case 2 – Client‑assertion delegate
+            // ────────────────────────────────────
+            if (serviceBundle.Config.ClientCredential is ClientAssertionDelegateCredential cadc)
+            {
+                var opts = new AssertionRequestOptions
+                {
+                    ClientID = serviceBundle.Config.ClientId,
+                    ClientCapabilities = serviceBundle.Config.ClientCapabilities,
+                    Claims = commonParameters.Claims,
+                    CancellationToken = ct
+                };
+
+                ClientAssertion ar = await cadc.GetAssertionAsync(opts, ct).ConfigureAwait(false);
+
+                if (ar.TokenBindingCertificate == null)
+                {
+                    throw new MsalClientException(
+                        MsalError.MtlsCertificateNotProvided,
+                        MsalErrorMessage.MtlsCertificateNotProvidedMessage);
+                }
+
+                Wire(commonParameters, ar.TokenBindingCertificate, serviceBundle);
+                return;
+            }
+
+            // ────────────────────────────────────
+            // Case 3 – Any other credential (client‑secret etc.)
+            // ────────────────────────────────────
+            throw new MsalClientException(
+                MsalError.MtlsCertificateNotProvided,
+                MsalErrorMessage.MtlsCertificateNotProvidedMessage);
+        }
+
+        /// <summary>
+        /// Common wiring + region check.
+        /// </summary>
+        private static void Wire(
+            AcquireTokenCommonParameters commonParameters,
+            X509Certificate2 cert,
+            IServiceBundle serviceBundle)
+        {
+            // Region requirement (AAD only)
+            if (serviceBundle.Config.Authority.AuthorityInfo.AuthorityType == AuthorityType.Aad &&
+                serviceBundle.Config.AzureRegion == null)
+            {
+                throw new MsalClientException(
+                    MsalError.MtlsPopWithoutRegion,
+                    MsalErrorMessage.MtlsPopWithoutRegion);
+            }
+
+            commonParameters.AuthenticationOperation = new MtlsPopAuthenticationOperation(cert);
+            commonParameters.MtlsCertificate = cert;
+
+            commonParameters.CacheKeyComponents ??= new SortedList<string, string>(StringComparer.Ordinal);
+
+            commonParameters.CacheKeyComponents[Constants.CertSerialNumber] = cert.SerialNumber;
+
+            serviceBundle.Config.CertificateIdToAssociateWithToken = cert.Thumbprint;
+        }
+    }
+}

src/client/Microsoft.Identity.Client/Internal/ClientCredential/ClientAssertionDelegateCredential.cs

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Identity.Client;
+using Microsoft.Identity.Client.AuthScheme.PoP;
+using Microsoft.Identity.Client.Core;
+using Microsoft.Identity.Client.Internal.Requests;
+using Microsoft.Identity.Client.OAuth2;
+using Microsoft.Identity.Client.PlatformsCommon.Interfaces;
+using Microsoft.Identity.Client.TelemetryCore;
+
+namespace Microsoft.Identity.Client.Internal.ClientCredential
+{
+    /// <summary>
+    /// Handles client assertions supplied via a delegate that returns an
+    /// <see cref="ClientAssertion"/> (JWT + optional certificate bound for mTLS‑PoP).
+    /// </summary>
+    internal sealed class ClientAssertionDelegateCredential : IClientCredential
+    {
+        private readonly Func<AssertionRequestOptions, CancellationToken, Task<ClientAssertion>> _provider;
+
+        internal Task<ClientAssertion> GetAssertionAsync(
+                AssertionRequestOptions options,
+                CancellationToken cancellationToken) =>
+            _provider(options, cancellationToken);
+
+        public ClientAssertionDelegateCredential(
+            Func<AssertionRequestOptions, CancellationToken, Task<ClientAssertion>> provider)
+        {
+            _provider = provider ?? throw new ArgumentNullException(nameof(provider));
+        }
+
+        public AssertionType AssertionType => AssertionType.ClientAssertion;
+
+        // ──────────────────────────────────
+        //  Main hook for token requests
+        // ──────────────────────────────────
+        public async Task AddConfidentialClientParametersAsync(
+            OAuth2Client oAuth2Client,
+            AuthenticationRequestParameters p,
+            ICryptographyManager _,
+            string tokenEndpoint,
+            CancellationToken ct)
+        {
+            var opts = new AssertionRequestOptions
+            {
+                CancellationToken = ct,
+                ClientID = p.AppConfig.ClientId,
+                TokenEndpoint = tokenEndpoint,
+                ClientCapabilities = p.RequestContext.ServiceBundle.Config.ClientCapabilities,
+                Claims = p.Claims,
+                ClientAssertionFmiPath = p.ClientAssertionFmiPath
+            };
+
+            ClientAssertion resp = await _provider(opts, ct).ConfigureAwait(false);
+
+            if (string.IsNullOrWhiteSpace(resp?.Assertion))
+            {
+                throw new MsalClientException(MsalError.InvalidClientAssertion,
+                    MsalErrorMessage.InvalidClientAssertionEmpty);
+            }
+
+            // Decide bearer vs mTLS PoP
+            bool isMtlsPopEnabled = p.IsMtlsPopEnabled;
+
+            if (isMtlsPopEnabled && resp.TokenBindingCertificate != null)
+            {
+                oAuth2Client.AddBodyParameter(
+                    OAuth2Parameter.ClientAssertionType,
+                    OAuth2AssertionType.JwtPop /* constant added in OAuth2AssertionType */);
+            }
+            else
+            {
+                oAuth2Client.AddBodyParameter(
+                    OAuth2Parameter.ClientAssertionType,
+                    OAuth2AssertionType.JwtBearer);
+            }
+
+            oAuth2Client.AddBodyParameter(OAuth2Parameter.ClientAssertion, resp.Assertion);
+        }
+    }
+}