.Net-Core-Web-Api-Schlüssel

Ich entwickle eine Anwendung, die Benutzer können die Authentifizierung über Benutzername und Kennwort, und wir bieten eine JWT token bekommt dann auf dem server überprüft.

Eine Sache, die ich hinzufügen möchte, ist die Möglichkeit, einen speziellen API-Schlüssel (guid), die die Benutzer verwenden können, wenn die Integration mit dieser Anwendung statt mit einem Benutzernamen und Passwort.

Ich bin nicht sicher, wie dies zu tun, da die Authentifizierung Teil scheint ein bisschen eine "black box" (mit Aspnet-Identität).

Hier ist mein code für die Authentifizierung einrichten.

Start.cs

public void ConfigureServices(IServiceCollection services)
{
    //Add framework services.
    services.AddDbContext<OmbiContext>(options =>
        options.UseSqlite("Data Source=Ombi.db"));

    services.AddIdentity<OmbiUser, IdentityRole>()
        .AddEntityFrameworkStores<OmbiContext>()
        .AddDefaultTokenProviders();

    services.Configure<IdentityOptions>(options =>
    {
        options.Password.RequireDigit = false;
        options.Password.RequiredLength = 1;
        options.Password.RequireLowercase = false;
        options.Password.RequireNonAlphanumeric = false;
        options.Password.RequireUppercase = false;
    });
}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IMemoryCache cache)
{
    var tokenOptions = (IOptions<TokenAuthentication>)app.ApplicationServices.GetService(
        typeof(IOptions<TokenAuthentication>));

    var ctx = (IOmbiContext)app.ApplicationServices.GetService(typeof(IOmbiContext));

    var tokenValidationParameters = new TokenValidationParameters
    {

        ValidateIssuerSigningKey = true,
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(tokenOptions.Value.SecretKey)),

        RequireExpirationTime = true,
        ValidateLifetime = true,
        ValidAudience = "Ombi",
        ValidIssuer = "Ombi",
        ClockSkew = TimeSpan.Zero
    };

    app.UseJwtBearerAuthentication(new JwtBearerOptions()
    {
        Audience = "Ombi",
        AutomaticAuthenticate = true,
        TokenValidationParameters =  tokenValidationParameters,

    });
 //....
}

Der obige code funktioniert, wenn ich die [Authorized] Parametern auf Steuerungen und Kontrolle für die Rollen und so.

Jemand eine Idee, wie ich das übergeben kann eine Art von Api-Key header auf alle Anfragen mit diesem speziellen API-Key übergeben werden, die [Authorized] Attribute? (der Schlüssel ist gespeichert in der Db).

Dank

stackoverflow.com/questions/31464359/...
Nicht sicher, ob das oben gilt es bei der Suche würde ich brauchen, um zu definieren, dass Politik für jeden controller, in diesem Fall die API-Key-header würde dann immer vorhanden sein müssen. Im Grunde Suche ich nach einem Weg, um ein Geheimnis um die server, die autorisiert mich.
Sie versorgen den Träger token Authorization-header in der Anfrage. Und je nach Autorisierung-server befinden, müssen Sie, um ihn zu validieren. I. e. In azure-AD-fügen Sie eine api unter appregistration, wenn Sie nur wollen, um zu validieren gegen einen hardcoded key-in server können Sie überprüfen, indem Sie die eigenen Ansprüche validator überprüfen AuthorizationHandler Klasse

InformationsquelleAutor Jamie Rees | 2017-08-21

Dies ist, was ich Tat, am Ende:

 public static void ApiKeyMiddlewear(this IApplicationBuilder app, IServiceProvider serviceProvider)
    {
        app.Use(async (context, next) =>
        {
            if (context.Request.Path.StartsWithSegments(new PathString("/api")))
            {
                //Let's check if this is an API Call
                if (context.Request.Headers["ApiKey"].Any())
                {
                    //validate the supplied API key
                    //Validate it
                    var headerKey = context.Request.Headers["ApiKey"].FirstOrDefault();
                    await ValidateApiKey(serviceProvider, context, next, headerKey);
                }
                else if (context.Request.Query.ContainsKey("apikey"))
                {
                    if (context.Request.Query.TryGetValue("apikey", out var queryKey))
                    {
                        await ValidateApiKey(serviceProvider, context, next, queryKey);
                    }
                }
                else
                {
                    await next();
                }
            }
            else
            {
                await next();
            }
        });
    }

    private static async Task ValidateApiKey(IServiceProvider serviceProvider, HttpContext context, Func<Task> next, string key)
    {
        //validate it here
        var valid = false;
        if (!valid)
        {
            context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
            await context.Response.WriteAsync("Invalid API Key");
        }
        else
        {
            var identity = new GenericIdentity("API");
            var principal = new GenericPrincipal(identity, new[] { "Admin", "ApiUser" });
            context.User = principal;
            await next();
        }
    }

Dieser hat sich ziemlich geändert, seit ich antwortete auf die ursprüngliche Frage (Antwort ist immer noch gültig). Aber Lesen Sie dazu hier: http://jamietech.com/2019/03/25/net-core-jwt-api-key/

Können Sie erläutern, was Sie erreichen wollen, auf der anderen Körper des ValidateApiKey? Meine Bedenken sind zur Validierung der ApiKey, aber dann immer abgelehnt, mit Maßnahmen, die mit dem Attribut [Autorisieren]. Wie handhabt Ihr das als middleware für Schritt über das Attribut?
Im Grunde await context.Response.WriteAsync("Invalid API Key"); dann " auf weiter.Invoke(context);`. Können Sie sehen, dieses hier: github.com/tidusjar/Ombi/blob/master/src/Ombi/...
Hey @JamieRees Dank für diese Lösung, es hat mir sehr geholfen! Was hältst du von insted Prüfung für einen ApiKey, suchen wir für die client_id und überprüfen Sie, ob die client_id hat Zugriff auf einen geschützten Bereich (wie eine Api-Ressource)?

InformationsquelleAutor Jamie Rees

1

Gibt es einen schönen Artikel über die Verwendung von api-keys im header-Anfragen auf diesen link:
http://www.mithunvp.com/write-custom-asp-net-core-middleware-web-api/

Zusammenzufassen, in ASP.NET Kern , können Sie mit Middleware zur Steuerung die http-pipeline-Konfiguration. Middleware effektiv ersetzt HttpHandlers, die verwendet wurden, in ealier Versionen von asp.net MVC.

InformationsquelleAutor Mwiza

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.