Azure AD B2C mit ASP.NET-Core - Ich kann nicht gehen, um Profil zu bearbeiten

Question

Ich habe versucht, Fragen zu diesem Thema suchen, konnte aber nichts finden.

Ich habe eine ASP.NET Core 1.0 App, die Azure AD B2C für die Authentifizierung verwendet. Das Anmelden und Registrieren sowie das Abmelden funktionieren einwandfrei. Das Problem tritt auf, wenn ich versuche, das Profil des Benutzers zu bearbeiten. Hier ist, was meine Startup.cs wie folgt aussieht:

namespace AspNetCoreBtoC 
{ 
    public class Startup 
    { 
     private IConfigurationRoot Configuration { get; } 

     public Startup(IHostingEnvironment env) 
     { 
      var builder = new ConfigurationBuilder() 
          .SetBasePath(env.ContentRootPath) 
          .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) 
          .AddEnvironmentVariables(); 
      Configuration = builder.Build(); 
     } 

     // This method gets called by the runtime. Use this method to add services to the container. 
     // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=398940 
     public void ConfigureServices(IServiceCollection services) 
     { 
      services.AddSingleton<IConfiguration>(Configuration); 
      services.AddMvc(); 
      services.AddAuthentication(
       opts => opts.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme); 
     } 

     // This method gets called by the runtime. Use this method to configure the HTTP request pipeline. 
     public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) 
     { 
      loggerFactory.AddConsole(); 

      if (env.IsDevelopment()) 
      { 
       loggerFactory.AddDebug(LogLevel.Debug); 
       app.UseDeveloperExceptionPage(); 
      } 

      app.UseStaticFiles(); 

      app.UseCookieAuthentication(new CookieAuthenticationOptions 
      { 
       AutomaticChallenge = false 
      }); 

      string signUpPolicyId = Configuration["AzureAd:SignUpPolicyId"]; 
      string signUpCallbackPath = Configuration["AzureAd:SignUpCallbackPath"]; 
      app.UseOpenIdConnectAuthentication(CreateOidConnectOptionsForPolicy(signUpPolicyId, false, signUpCallbackPath)); 

      string userProfilePolicyId = Configuration["AzureAd:UserProfilePolicyId"]; 
      string profileCallbackPath = Configuration["AzureAd:ProfileCallbackPath"]; 
      app.UseOpenIdConnectAuthentication(CreateOidConnectOptionsForPolicy(userProfilePolicyId, false, profileCallbackPath)); 

      string signInPolicyId = Configuration["AzureAd:SignInPolicyId"]; 
      string signInCallbackPath = Configuration["AzureAd:SignInCallbackPath"]; 
      app.UseOpenIdConnectAuthentication(CreateOidConnectOptionsForPolicy(signInPolicyId, true, signInCallbackPath)); 

      app.UseMvc(routes => 
      { 
       routes.MapRoute(
        name: "Default", 
        template: "{controller=Home}/{action=Index}/{id?}"); 
      }); 
     } 

     private OpenIdConnectOptions CreateOidConnectOptionsForPolicy(string policyId, bool autoChallenge, string callbackPath) 
     { 
      string aadInstance = Configuration["AzureAd:AadInstance"]; 
      string tenant = Configuration["AzureAd:Tenant"]; 
      string clientId = Configuration["AzureAd:ClientId"]; 
      string redirectUri = Configuration["AzureAd:RedirectUri"]; 

      var opts = new OpenIdConnectOptions 
      { 
       AuthenticationScheme = policyId, 
       MetadataAddress = string.Format(aadInstance, tenant, policyId), 
       ClientId = clientId, 
       PostLogoutRedirectUri = redirectUri, 
       ResponseType = "id_token", 
       TokenValidationParameters = new TokenValidationParameters 
       { 
        NameClaimType = "name" 
       }, 
       CallbackPath = callbackPath, 
       AutomaticChallenge = autoChallenge 
      }; 

      opts.Scope.Add("openid"); 

      return opts; 
     } 
    } 
} 

hier meine Account ist, von wo aus ich die Herausforderungen an die Middleware Ausgabe:

namespace AspNetCoreBtoC.Controllers 
{ 
    public class AccountController : Controller 
    { 
     private readonly IConfiguration config; 

     public AccountController(IConfiguration config) 
     { 
      this.config = config; 
     } 

     public IActionResult SignIn() 
     { 
      return Challenge(new AuthenticationProperties 
      { 
       RedirectUri = "/" 
      }, 
      config["AzureAd:SignInPolicyId"]); 
     } 

     public IActionResult SignUp() 
     { 
      return Challenge(new AuthenticationProperties 
      { 
       RedirectUri = "/" 
      }, 
      config["AzureAd:SignUpPolicyId"]); 
     } 

     public IActionResult EditProfile() 
     { 
      return Challenge(new AuthenticationProperties 
      { 
       RedirectUri = "/" 
      }, 
      config["AzureAd:UserProfilePolicyId"]); 
     } 

     public IActionResult SignOut() 
     { 
      string returnUrl = Url.Action(
       action: nameof(SignedOut), 
       controller: "Account", 
       values: null, 
       protocol: Request.Scheme); 
      return SignOut(new AuthenticationProperties 
      { 
       RedirectUri = returnUrl 
      }, 
      config["AzureAd:UserProfilePolicyId"], 
      config["AzureAd:SignUpPolicyId"], 
      config["AzureAd:SignInPolicyId"], 
      CookieAuthenticationDefaults.AuthenticationScheme); 
     } 

     public IActionResult SignedOut() 
     { 
      return View(); 
     } 
    } 
} 

Ich habe versucht, es aus dem OWIN Beispiel anzupassen . Das Problem, das ich habe, ist, dass ich eine Herausforderung an die OpenIdConnect-Middleware, die dafür zuständig ist, stellen muss, um das Profil zu bearbeiten. Das Problem ist, dass es die Standardanmeldung in der Middleware (Cookies) aufruft, die erkennt, dass der Benutzer authentifiziert ist, also die Aktion etwas nicht autorisiert haben muss, und versucht, nach/Account/AccessDenied umzuleiten (obwohl ich nicht einmal haben Sie etwas auf dieser Route), anstatt zu Azure AD zu gehen, um das Profil wie gewünscht zu bearbeiten.

Hat jemand erfolgreich Benutzerprofil bearbeiten in ASP.NET Core implementiert?

Answer 1

Nun, ich habe es endlich gelöst. Ich schrieb einen Blog-Artikel über das Setup, der die Lösung enthält: https://joonasw.net/view/azure-ad-b2c-with-aspnet-core. Das Problem war ChallengeBehavior, das anstelle des Standardwerts Automatisch auf Nicht autorisiert festgelegt werden muss. Es war nicht möglich, sie mit dem Rahmen ChallengeResult im Moment zu definieren, so dass ich meine eigenen:

public class MyChallengeResult : IActionResult 
{ 
    private readonly AuthenticationProperties authenticationProperties; 
    private readonly string[] authenticationSchemes; 
    private readonly ChallengeBehavior challengeBehavior; 

    public MyChallengeResult(
     AuthenticationProperties authenticationProperties, 
     ChallengeBehavior challengeBehavior, 
     string[] authenticationSchemes) 
    { 
     this.authenticationProperties = authenticationProperties; 
     this.challengeBehavior = challengeBehavior; 
     this.authenticationSchemes = authenticationSchemes; 
    } 

    public async Task ExecuteResultAsync(ActionContext context) 
    { 
     AuthenticationManager authenticationManager = 
      context.HttpContext.Authentication; 

     foreach (string scheme in authenticationSchemes) 
     { 
      await authenticationManager.ChallengeAsync(
       scheme, 
       authenticationProperties, 
       challengeBehavior); 
     } 
    } 
} 

Sorry für den Namen ... Aber das kann man von einer Controller-Aktion zurückgegeben werden, und durch die Angabe ChallengeBehavior.Unauthorified, ich habe alles funktioniert wie es sollte.