Autenticazione JWT e Swagger con .Net core 3.0

Sto sviluppando alcune API Web con .Net core 3.0 e voglio integrarlo con SwashBuckle.Swagger. Funziona bene, ma quando aggiungo l'autenticazione JWT, non funziona come mi aspetto. Per fare ciò, ho aggiunto il seguente codice:

  services.AddSwaggerGen(c =>
        {
            c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo { Title = "My Web API", Version = "v1" });
            c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
            {
                Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
                Name = "Authorization",
                In = ParameterLocation.Header,
                Type = SecuritySchemeType.ApiKey
            });

        });

Dopo aver aggiunto la AddSecurityDefinitionfunzione, posso vedere il pulsante Autorizza e quando faccio clic su di esso, vedo il modulo seguente:

Quindi digito Bearer WhatEverApiKeyIsfgdgdgdg845734987fgdhgiher635kjh, dopo averlo fatto mi aspetto di vedere authorization: Bearer WhatEverApiKeyIsfgdgdgdg845734987fgdhgiher635kjhnell'intestazione della richiesta, quando invio una richiesta all'API Web da Swagger. Ma l'autorizzazione non viene aggiunta all'intestazione della richiesta. Sto usando SwashBuckle.Swagger (5.0.0-rc3). Nota: ci sono molti esempi che funzionano bene su .net core 2.0, ma le funzioni dello swaggbuckle Swashbuckle sono cambiate sull'ultima versione, quindi non posso usare quegli esempi.

Dopo alcune ricerche, ho finalmente trovato la risposta qui

Prima di vedere questa pagina, sapevo che avrei dovuto usarlo AddSecurityRequirementdopo AddSecurityDefinitionmolti esempi, ma era un problema che i parametri della funzione fossero cambiati su .NET Core 3.0.

A proposito, la risposta finale è la seguente:

services.AddSwaggerGen(c =>
{
  c.SwaggerDoc("v1", new OpenApiInfo { 
    Title = "My API", 
    Version = "v1" 
  });
  c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme {
    In = ParameterLocation.Header, 
    Description = "Please insert JWT with Bearer into field",
    Name = "Authorization",
    Type = SecuritySchemeType.ApiKey 
  });
  c.AddSecurityRequirement(new OpenApiSecurityRequirement {
   { 
     new OpenApiSecurityScheme 
     { 
       Reference = new OpenApiReference 
       { 
         Type = ReferenceType.SecurityScheme,
         Id = "Bearer" 
       } 
      },
      new string[] { } 
    } 
  });
});

Se si utilizza Swagger 3.0, dispone del supporto integrato per l'autenticazione JWT.

È necessario utilizzare ParameterLocation.Header, SecuritySchemeType.Http, bearer e JWT in OpenApiSecurityScheme come mostrato di seguito.

Dopo questo, tu non è necessario specificare il token nel formato Bearer {token} . Specifica solo il token e lo schema di sicurezza lo applicherà automaticamente nell'intestazione.

// Bearer token authentication
OpenApiSecurityScheme securityDefinition = new OpenApiSecurityScheme()
{
    Name = "Bearer",
    BearerFormat = "JWT",
    Scheme = "bearer",
    Description = "Specify the authorization token.",
    In = ParameterLocation.Header,
    Type = SecuritySchemeType.Http,
};
c.AddSecurityDefinition("jwt_auth", securityDefinition);

// Make sure swagger UI requires a Bearer token specified
OpenApiSecurityScheme securityScheme = new OpenApiSecurityScheme()
{
    Reference = new OpenApiReference()
    {
        Id = "jwt_auth",
        Type = ReferenceType.SecurityScheme
    }
};
OpenApiSecurityRequirement securityRequirements = new OpenApiSecurityRequirement()
{
    {securityScheme, new string[] { }},
};
c.AddSecurityRequirement(securityRequirements);

Se non si desidera aggiungere un token manualmente e si desidera che gli ambiti siano selezionabili insieme al passaggio di un ID client al server delle identità, è possibile aggiungere qualcosa del genere.

Ho utilizzato il flusso implicito, ma è possibile configurare qualsiasi flusso utilizzando il seguente meccanismo:

options.AddSecurityDefinition("oauth2", new OpenApiSecurityScheme()
{
  Flows = new OpenApiOAuthFlows
  {
    Implicit = new OpenApiOAuthFlow
    {                            
      AuthorizationUrl = new Uri("http://localhost"),
      TokenUrl = new Uri("http://localhost"),
      Scopes = new Dictionary<string, string>
      {
        { "Foundation API", "FoundationApi" }
      }
    }
  },
  In = ParameterLocation.Header,                    
  Name = "Authorization",
  Type = SecuritySchemeType.OAuth2                    
});

L'output sarà così:

Ecco una soluzione aggiornata per Swashbuckle.AspNetCore 5.3.2, integrata con IdentityServer4, con un'API protetta mediante un token Bearer.

Nel ConfigureServices()metodo:

        services.AddSwaggerGen(options =>
        {
            options.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
            options.AddSecurityDefinition("Bearer", SecuritySchemes.BearerScheme(Configuration));
            options.AddSecurityRequirement(new OpenApiSecurityRequirement()
            {
                { SecuritySchemes.OAuthScheme, new List<string>() }
            });
        });

Nel Configure()metodo:

        app.UseSwaggerUI(options =>
        {
            options.SwaggerEndpoint("/My.Api/swagger/v1/swagger.json", "My API V1");
            options.OAuthClientId(Clients.TestClient);
            options.OAuthAppName("My Api - Swagger");
            options.OAuthClientSecret(Configuration["TestClientSecret"]);
        });

internal static class SecuritySchemes
{
    public static OpenApiSecurityScheme BearerScheme(IConfiguration config) => new OpenApiSecurityScheme
    {
        Type = SecuritySchemeType.OAuth2,
        Description = "Standard authorisation using the Bearer scheme. Example: \"bearer {token}\"",
        In = ParameterLocation.Header,
        Name = "Authorization",
        Scheme = "Bearer",
        OpenIdConnectUrl = new System.Uri($"{config["TokenServerUrl"]}.well-known/openid-configuration"),
        BearerFormat = "JWT",
        Flows = new OpenApiOAuthFlows
        {
            Password = new OpenApiOAuthFlow
            {
                AuthorizationUrl = new System.Uri($"{config["TokenServerUrl"]}connect/authorize"),
                Scopes = new Dictionary<string, string>
                    {
                        { Scopes.Api, "My Api" }
                    },
                TokenUrl = new System.Uri($"{config["TokenServerUrl"]}connect/token")
            }
        }
    };

    public static OpenApiSecurityScheme OAuthScheme => new OpenApiSecurityScheme
    {
        Reference = new OpenApiReference
        {
            Type = ReferenceType.SecurityScheme,
            Id = "Bearer"
        },
        Scheme = "oauth2",
        Name = "Bearer",
        In = ParameterLocation.Header,

    };
}

Se qualcuno sta usando NSwag ed è atterrato qui dopo aver cercato la soluzione, ecco il link dalla documentazione ufficiale.

NSwag Abilita autenticazione JWT

PS: So che la domanda originale era per SwashBuckle, ma Google mostra questo link prima anche durante la ricerca di NSwag.