Lozensky/enable managed identity

src/Microsoft.Identity.Web.TokenAcquisition/DefaultAuthorizationHeaderProvider.cs

@@ -49,19 +49,9 @@ public async Task<string> CreateAuthorizationHeaderForAppAsync(string scopes, Au
 
         private static TokenAcquisitionOptions CreateTokenAcquisitionOptionsFromApiOptions(AuthorizationHeaderProviderOptions? downstreamApiOptions, CancellationToken cancellationToken)
         {
-            return new TokenAcquisitionOptions()
-            {
-                AuthenticationOptionsName = downstreamApiOptions?.AcquireTokenOptions.AuthenticationOptionsName,
-                CancellationToken = cancellationToken,
-                Claims = downstreamApiOptions?.AcquireTokenOptions.Claims,
-                CorrelationId = downstreamApiOptions?.AcquireTokenOptions.CorrelationId ?? Guid.Empty,
-                ExtraQueryParameters = downstreamApiOptions?.AcquireTokenOptions.ExtraQueryParameters,
-                ForceRefresh = downstreamApiOptions?.AcquireTokenOptions.ForceRefresh ?? false,
-                LongRunningWebApiSessionKey = downstreamApiOptions?.AcquireTokenOptions.LongRunningWebApiSessionKey,
-                Tenant = downstreamApiOptions?.AcquireTokenOptions.Tenant,
-                UserFlow = downstreamApiOptions?.AcquireTokenOptions.UserFlow,
-                PopPublicKey = downstreamApiOptions?.AcquireTokenOptions.PopPublicKey,
-            };
+            TokenAcquisitionOptions tokenAcquisitionOptions = TokenAcquisitionOptions.CloneFromBaseClass(downstreamApiOptions?.AcquireTokenOptions);
+            tokenAcquisitionOptions.CancellationToken = cancellationToken;
+            return tokenAcquisitionOptions;
         }
     }
 }

src/Microsoft.Identity.Web.TokenAcquisition/TokenAcquisition.cs

@@ -18,12 +18,13 @@
 using Microsoft.Identity.Abstractions;
 using Microsoft.Identity.Client;
 using Microsoft.Identity.Client.Advanced;
+using Microsoft.Identity.Client.AppConfig;
 using Microsoft.Identity.Client.Extensibility;
+using Microsoft.Identity.Web.Experimental;
 using Microsoft.Identity.Web.TokenCacheProviders;
 using Microsoft.Identity.Web.TokenCacheProviders.InMemory;
 using Microsoft.IdentityModel.JsonWebTokens;
 using Microsoft.IdentityModel.Tokens;
-using Microsoft.Identity.Web.Experimental;
 
 namespace Microsoft.Identity.Web
 {
@@ -45,11 +46,14 @@ class OAuthConstants
         protected readonly IMsalTokenCacheProvider _tokenCacheProvider;
 
         private readonly object _applicationSyncObj = new();
+        private readonly SemaphoreSlim _managedIdSemaphore = new(1, 1);
 
         /// <summary>
-        ///  Please call GetOrBuildConfidentialClientApplication instead of accessing this field directly.
+        ///  Please call GetOrBuildConfidentialClientApplication instead of accessing _applicationsByAuthorityClientId directly.
         /// </summary>
-        private readonly ConcurrentDictionary<string, IConfidentialClientApplication?> _applicationsByAuthorityClientId = new ConcurrentDictionary<string, IConfidentialClientApplication?>();
+        private readonly ConcurrentDictionary<string, IConfidentialClientApplication?> _applicationsByAuthorityClientId = new();
+        private readonly ConcurrentDictionary<string, IManagedIdentityApplication> _managedIdentityApplicationsByClientId = new();
+        private const string SystemAssignedManagedIdentityKey = "SYSTEM";
         private bool _retryClientCertificate;
         protected readonly IMsalHttpClientFactory _httpClientFactory;
         protected readonly ILogger _logger;
@@ -321,9 +325,10 @@ private void LogAuthResult(AuthenticationResult? authenticationResult)
 
         /// <summary>
         /// Acquires an authentication result from the authority configured in the app, for the confidential client itself (not on behalf of a user)
-        /// using the client credentials flow. See https://aka.ms/msal-net-client-credentials.
+        /// using either a client credentials or managed identity flow. See https://aka.ms/msal-net-client-credentials for client credentials or
+        /// https://aka.ms/Entra/ManagedIdentityOverview for managed identity.
         /// </summary>
-        /// <param name="scope">The scope requested to access a protected API. For this flow (client credentials), the scope
+        /// <param name="scope">The scope requested to access a protected API. For these flows (client credentials or managed identity), the scope
         /// should be of the form "{ResourceIdUri/.default}" for instance <c>https://management.azure.net/.default</c> or, for Microsoft
         /// Graph, <c>https://graph.microsoft.com/.default</c> as the requested scopes are defined statically with the application registration
         /// in the portal, and cannot be overridden in the application, as you can request a token for only one resource at a time (use
@@ -358,10 +363,28 @@ public async Task<AuthenticationResult> GetAuthenticationResultForAppAsync(
                 throw new ArgumentException(IDWebErrorMessage.ClientCredentialTenantShouldBeTenanted, nameof(tenant));
             }
 
+            // If using managed identity 
+            if (tokenAcquisitionOptions != null && tokenAcquisitionOptions.ManagedIdentity != null)
+            {
+                try
+                {
+                    IManagedIdentityApplication managedIdApp = await GetOrBuildManagedIdentityApplication(
+                        mergedOptions, 
+                        tokenAcquisitionOptions.ManagedIdentity
+                    );
+                    return await managedIdApp.AcquireTokenForManagedIdentity(scope).ExecuteAsync().ConfigureAwait(false);
+                }
+                catch(Exception ex)
+                {
+                    Logger.TokenAcquisitionError(_logger, ex.Message, ex);
+                    throw;
+                }
+            }
+
             // Use MSAL to get the right token to call the API
-            var application = GetOrBuildConfidentialClientApplication(mergedOptions);
+            IConfidentialClientApplication application = GetOrBuildConfidentialClientApplication(mergedOptions);
 
-            var builder = application
+            AcquireTokenForClientParameterBuilder builder = application
                    .AcquireTokenForClient(new[] { scope }.Except(_scopesRequestedByMsal))
                    .WithSendX5C(mergedOptions.SendX5C);
 
@@ -585,10 +608,82 @@ private bool IsInvalidClientCertificateOrSignedAssertionError(MsalServiceExcepti
                     _applicationsByAuthorityClientId.TryAdd(GetApplicationKey(mergedOptions), application);
                 }
             }
+            return application;
+        }
+
+        /// <summary>
+        /// Gets a cached ManagedIdentityApplication object or builds a new one if not found.
+        /// </summary>
+        /// <param name="mergedOptions">The configuration options for the app.</param>
+        /// <param name="managedIdentityOptions">The configuration specific to managed identity.</param>
+        /// <returns>The application object used to request a token with managed identity.</returns>
+        internal async Task<IManagedIdentityApplication> GetOrBuildManagedIdentityApplication(
+            MergedOptions mergedOptions, ManagedIdentityOptions managedIdentityOptions)
+        {
+            string key = GetCacheKeyForManagedId(managedIdentityOptions);
+
+            // Check if the application is already built, if so return it without grabbing the lock
+            if (_managedIdentityApplicationsByClientId.TryGetValue(key, out IManagedIdentityApplication? application))
+            {
+                return application;
+            }
+
+            // Lock the potential write of the dictionary to prevent multiple threads from creating the same application.
+            await _managedIdSemaphore.WaitAsync();
+            try
+            {
+                // Check if the application is already built (could happen between previous check and obtaining the key)
+                if (_managedIdentityApplicationsByClientId.TryGetValue(key, out application))
+                {
+                    return application;
+                }
+
+                // Set managedIdentityId to the correct value for either system or user assigned
+                ManagedIdentityId managedIdentityId;
+                if (key == SystemAssignedManagedIdentityKey)
+                {
+                    managedIdentityId = ManagedIdentityId.SystemAssigned;
+                }
+                else
+                {
+                    managedIdentityId = ManagedIdentityId.WithUserAssignedClientId(key);
+                }
+
+                // Build the application
+                application = BuildManagedIdentityApplication(
+                    managedIdentityId,
+                    mergedOptions.ConfidentialClientApplicationOptions.EnablePiiLogging
+                );
 
+                // Add the application to the cache
+                _managedIdentityApplicationsByClientId.TryAdd(key, application);
+            }
+            finally
+            {
+                // Now that the dictionary is updated, release the semaphore
+                _managedIdSemaphore.Release();
+            }
             return application;
         }
 
+        /// <summary>
+        /// Gets the key value for the Managed Identity cache, the default key for system-assigned identity is used if there is
+        /// no clientId for a user-assigned identity specified. The method is internal rather than private for testing purposes.
+        /// </summary>
+        /// <param name="managedIdOptions">Holds the clientId for managed identity if none is present</param>
+        /// <returns>A key value for the Managed Identity cache</returns>
+        internal static string GetCacheKeyForManagedId(ManagedIdentityOptions managedIdOptions) 
+        {
+            if (managedIdOptions.UserAssignedClientId.IsNullOrEmpty())
+            {
+                return SystemAssignedManagedIdentityKey;
+            }
+            else
+            {
+                return managedIdOptions.UserAssignedClientId!;
+            }
+        }
+
         /// <summary>
         /// Creates an MSAL confidential client application.
         /// </summary>
@@ -599,7 +694,7 @@ private IConfidentialClientApplication BuildConfidentialClientApplication(Merged
 
             try
             {
-                var builder = ConfidentialClientApplicationBuilder
+                ConfidentialClientApplicationBuilder builder = ConfidentialClientApplicationBuilder
                         .CreateWithApplicationOptions(mergedOptions.ConfidentialClientApplicationOptions)
                         .WithHttpClientFactory(_httpClientFactory)
                         .WithLogging(
@@ -674,6 +769,26 @@ private IConfidentialClientApplication BuildConfidentialClientApplication(Merged
             }
         }
 
+        /// <summary>
+        /// Creates a managed identity client application.
+        /// </summary>
+        /// <param name="managedIdentityId">Indicates if system-assigned or user-assigned managed identity is used.</param>
+        /// <param name="enablePiiLogging">Indicates if logging that may contain personally identifiable information should be enabled.</param>
+        /// <returns>A managed identity application.</returns>
+        private IManagedIdentityApplication BuildManagedIdentityApplication(ManagedIdentityId managedIdentityId, bool enablePiiLogging)
+        {
+            return ManagedIdentityApplicationBuilder
+                .Create(managedIdentityId)
+                .WithHttpClientFactory(_httpClientFactory)
+                .WithLogging
+                (
+                    Log,
+                    ConvertMicrosoftExtensionsLogLevelToMsal(_logger),
+                    enablePiiLogging: enablePiiLogging
+                )
+                .Build();
+        }
+
         /// <summary>
         /// Find the certificate used by the app and fire the event to notify the client app that a certificate was selected/unselected.
         /// </summary>

src/Microsoft.Identity.Web.TokenAcquisition/TokenAcquisitionOptions.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using System;
 using System.Threading;
 using Microsoft.Identity.Abstractions;
 using Microsoft.Identity.Client.AppConfig;
@@ -25,6 +26,47 @@ public class TokenAcquisitionOptions : AcquireTokenOptions
         /// </summary>
         public CancellationToken CancellationToken { get; set; } = CancellationToken.None;
 
+        /// <summary>
+        /// Creates a new instance of TokenAcquisitionOptions from an instance of the base class AcquireTokenOptions.
+        /// </summary>
+        /// <param name="acquireTokenOptions">The instance of the base class to clone</param>
+        /// <returns>A new instance of TokenAquisitionOptions</returns>
+        public static TokenAcquisitionOptions CloneFromBaseClass(AcquireTokenOptions? acquireTokenOptions)
+        {
+            if (acquireTokenOptions == null)
+            {
+                return new TokenAcquisitionOptions();
+            }
+
+            // alternate option 1: serialize the base class then deserialize it back to the derived class, this is probably not
+            // ideal since it likely has small performance repercussions but it doesn't have to be done with json.
+
+            // alternate option 2: add the two extra fields of PoPConfiguration and CancellationToken to the base class in
+            // Abstractions and leave this child as a 1:1 wrapper with the base class to avoid breaking anyone.
+            // This is my personal preference as it is most performant since no conversion would be needed. The drawback is I'd
+            // need to replace all instances of TokenAcquisitionOptions with AcquireTokenOptions in the codebase.
+            //      2.1 - I spoke with JM and he said this would be a longer conversation as he wants to deprecate
+            //      TokenAcquisitionOptions entirely and drop the CancellationToken and PoPConfiguration fields as they
+            //      apparently don't belong in AcquireTokenOptions.
+
+            // This is how we have been doing it so far (in the DefaultAuthorizationHeaderProvider class) I put it here to make
+            // it easier to find if we ever add more fields to the base class, but it will still require manual intervention to
+            // add the new fields here.
+            return new TokenAcquisitionOptions
+            {
+                AuthenticationOptionsName = acquireTokenOptions.AuthenticationOptionsName,
+                Claims = acquireTokenOptions.Claims,
+                CorrelationId = acquireTokenOptions.CorrelationId ?? Guid.Empty,
+                ExtraQueryParameters = acquireTokenOptions.ExtraQueryParameters,
+                ForceRefresh = acquireTokenOptions.ForceRefresh,
+                LongRunningWebApiSessionKey = acquireTokenOptions.LongRunningWebApiSessionKey,
+                ManagedIdentity = acquireTokenOptions.ManagedIdentity,
+                Tenant = acquireTokenOptions.Tenant,
+                UserFlow = acquireTokenOptions.UserFlow,
+                PopPublicKey = acquireTokenOptions.PopPublicKey,
+            };
+        }
+
         /// <summary>
         /// Clone the options (to be able to override them).
         /// </summary>

tests/E2E Tests/TokenAcquirerTests/OnlyOnAzureDevopsFactAttribute.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using Xunit;
+
+namespace TokenAcquirerTests
+{
+    public sealed class OnlyOnAzureDevopsFactAttribute : FactAttribute
+    {
+        public OnlyOnAzureDevopsFactAttribute()
+        {
+            if (IgnoreOnAzureDevopsFactAttribute.IsRunningOnAzureDevOps())
+            {
+                return;
+            }
+            Skip = "Ignored when not on Azure DevOps";
+        }
+    }
+}

tests/E2E Tests/TokenAcquirerTests/TokenAcquirer.cs

@@ -3,9 +3,11 @@
 
 using System;
 using System.Linq;
+using System.Net.Http;
 using System.Security.Cryptography;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Microsoft.Graph;
@@ -299,5 +301,45 @@ private static async Task CreateGraphClientAndAssert(TokenAcquirerFactory tokenA
             Assert.NotNull(result.AccessToken);
         }
     }
+
+    public class AcquireTokenManagedIdentity 
+    {
+        [OnlyOnAzureDevopsFact]
+        //[Fact]
+        public async Task AcquireTokenWithManagedIdentity_UserAssigned()
+        {
+            const string scope = "https://vault.azure.net/.default";
+            const string baseUrl = "https://vault.azure.net";
+            const string clientId = "9c5896db-a74a-4b1a-a259-74c5080a3a6a";
+            TokenAcquirerFactory tokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance();
+            _ = tokenAcquirerFactory.Services;
+            IServiceProvider serviceProvider = tokenAcquirerFactory.Build();
+
+            // Get the authorization header provider and add the options to tell it to use Managed Identity
+            IAuthorizationHeaderProvider? api = serviceProvider.GetRequiredService<IAuthorizationHeaderProvider>();
+            Assert.NotNull(api);
+            string result = await api.CreateAuthorizationHeaderForAppAsync(scope, GetAuthHeaderOptions_ManagedId(baseUrl, clientId));
+
+            // Make sure we got a token
+            Assert.False(string.IsNullOrEmpty(result));
+        }
+
+        private static AuthorizationHeaderProviderOptions GetAuthHeaderOptions_ManagedId(string baseUrl, string? userAssignedClientId=null) 
+        {
+            ManagedIdentityOptions managedIdentityOptions = new()
+            {
+                UserAssignedClientId = userAssignedClientId
+            };
+            AcquireTokenOptions aquireTokenOptions = new()
+            {
+                ManagedIdentity = managedIdentityOptions
+            };
+            return new AuthorizationHeaderProviderOptions()
+            {
+                BaseUrl = baseUrl,
+                AcquireTokenOptions = aquireTokenOptions
+            };
+        }
+    }
 #endif //FROM_GITHUB_ACTION
 }

tests/Microsoft.Identity.Web.Test.Common/TestConstants.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Reflection;
 
 namespace Microsoft.Identity.Web.Test.Common
 {
@@ -186,8 +187,14 @@ public static class TestConstants
         public static readonly string s_todoListServicePath = Path.DirectorySeparatorChar.ToString() + "TodoListService";
 
 
-        // TokenAcqusitionOptions
+        // TokenAcqusitionOptions and ManagedIdentityOptions
         public static Guid s_correlationId = new Guid("6347d33d-941a-4c35-9912-a9cf54fb1b3e");
+        public const string UserAssignedManagedIdentityClientId = "3b57c42c-3201-4295-ae27-d6baec5b7027";
+        public const string UserAssignedManagedIdentityResourceId = "/subscriptions/c1686c51-b717-4fe0-9af3-24a20a41fb0c/" +
+            "resourcegroups/MSAL_MSI/providers/Microsoft.ManagedIdentity/userAssignedIdentities/" + "MSAL_MSI_USERID";
+        public const BindingFlags StaticPrivateFieldFlags = BindingFlags.GetField | BindingFlags.Static | BindingFlags.NonPublic;
+        public const BindingFlags InstancePrivateFieldFlags = BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic;
+        public const BindingFlags StaticPrivateMethodFlags = BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.NonPublic;
 
         // AadIssuerValidation
         public const string AadAuthority = "aadAuthority";

tests/Microsoft.Identity.Web.Test/Microsoft.Identity.Web.Test.csproj

@@ -18,6 +18,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="CommunityToolkit.HighPerformance" Version="8.2.2" />
     <PackageReference Include="Microsoft.Identity.Abstractions" Version="$(MicrosoftIdentityAbstractions)" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNetTestSdkVersion)" />
     <PackageReference Include="Newtonsoft.Json" Version="$(NewtonsoftJsonVersion)" />