Wie zu sichern eine ASP.NET Web-API

Update:

Ich habe meine andere Antwort wie zu verwenden JWT-Authentifizierung für die Web-API in hier für alle interessierten in der JWT:

JWT-Authentifizierung für Asp.Net Web-Api

Wir es geschafft haben, gelten HMAC-Authentifizierung auf sicheren Web-API, und es war okay. HMAC-Authentifizierung verwendet geheimen Schlüssel für jeden Verbraucher, der Verbraucher-und server beide wissen, hmac-hash einer Nachricht, HMAC256 verwendet werden soll. Die meisten der Fälle, gehashte Passwort der Verbraucher verwendet einen geheimen Schlüssel.

Die Nachricht normal ist gebaut von Daten in der HTTP-Anforderung, oder sogar kundenspezifische Daten, die Hinzugefügt wird, um HTTP-header der Nachricht enthalten sein:

1. Timestamp: die Zeit, die Anfrage wird gesendet (UTC oder GMT)
2. HTTP-Verben: GET, POST, PUT, DELETE.
3. post-Daten und query-string,
4. URL

Unter der Haube, HMAC-Authentifizierung:

Verbraucher sendet einen HTTP-request zum web-server, nach der Erstellung der Signatur (Ausgabe von hmac hash), die Vorlage der HTTP-Requests:

User-Agent: {agent}   
Host: {host}   
Timestamp: {timestamp}
Authentication: {username}:{signature}

Beispiel für eine GET Anfrage:

GET /webapi.hmac/api/values

User-Agent: Fiddler    
Host: localhost    
Timestamp: Thursday, August 02, 2012 3:30:32 PM 
Authentication: cuongle:LohrhqqoDy6PhLrHAXi7dUVACyJZilQtlDzNbLqzXlw=

Den Nachricht-hash zu erhalten, Signatur:

GET\n
Thursday, August 02, 2012 3:30:32 PM\n
/webapi.hmac/api/values\n

Beispiel für POST-request mit query-string (Signatur unten ist nicht korrekt, nur ein Beispiel)

POST /webapi.hmac/api/values?key2=value2

User-Agent: Fiddler    
Host: localhost    
Content-Type: application/x-www-form-urlencoded
Timestamp: Thursday, August 02, 2012 3:30:32 PM 
Authentication: cuongle:LohrhqqoDy6PhLrHAXi7dUVACyJZilQtlDzNbLqzXlw=

key1=value1&key3=value3

Den Nachricht-hash zu erhalten, Signatur

GET\n
Thursday, August 02, 2012 3:30:32 PM\n
/webapi.hmac/api/values\n
key1=value1&key2=value2&key3=value3

Bitte beachten Sie, dass die Formular-Daten und query-string sollte in Ordnung sein, damit der code auf dem server get-query-string und form-Daten zur Erstellung der richtigen Nachricht.

Wenn die HTTP-Anforderung an den server, eine Authentifizierungs-action-filter ist implementiert, um eine Analyse der Anfrage, Informationen zu erhalten: HTTP-verb, timestamp -, uri -, form-Daten und query-string, der dann auf dieser Grundlage zu bauen, Unterschrift (verwenden Sie hmac-hash) mit dem geheimen Schlüssel (Hash-Passwort) auf dem server.

Geheime Schlüssel habe aus der Datenbank mit dem Benutzernamen auf Anfrage.

Dann auf server-code vergleicht die Unterschrift auf dem Antrag mit der Unterschrift gebaut; wenn gleich, ist die Authentifizierung übergeben, andernfalls fehlgeschlagen.

Den code zu bauen-Signatur:

private static string ComputeHash(string hashedPassword, string message)
{
    var key = Encoding.UTF8.GetBytes(hashedPassword.ToUpper());
    string hashString;

    using (var hmac = new HMACSHA256(key))
    {
        var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(message));
        hashString = Convert.ToBase64String(hash);
    }

    return hashString;
}

So, wie verhindern von replay-Angriff?

Add constraint für den Zeitstempel, so etwas wie:

servertime - X minutes|seconds  <= timestamp <= servertime + X minutes|seconds 

(servertime: Zeitpunkt der Anfrage kommen zu server)

Und cache die Signatur der Anfrage im Speicher (verwenden Sie MemoryCache, sollte Sie in der limit-Zeit). Wenn die nächste Anfrage kommt mit der gleichen Signatur mit der vorherigen Anfrage, es wird abgelehnt werden.

Den demo-code ist gesetzt als hier:
https://github.com/cuongle/Hmac.WebApi

InformationsquelleAutor cuongle

Haben Sie versucht, DevDefined.OAuth?

Habe ich es benutzt zum sichern meiner WebApi mit 2-Legged OAuth. Ich habe auch erfolgreich getestet mit PHP-clients.

Ist es relativ einfach, um Unterstützung für OAuth verwenden diese Bibliothek. Hier ist, wie Sie implementieren können, der Anbieter für ASP.NET MVC-Web-API:

1) Holen Sie sich den source-code von DevDefined.OAuth: https://github.com/bittercoder/DevDefined.OAuth - die neueste version ermöglicht OAuthContextBuilder Erweiterbarkeit.

2) Aufbau der Bibliothek und verweisen Sie in Ihrem Web-API-Projekt.

3) Erstellen Sie eine benutzerdefinierte Kontext-generator zur Unterstützung der Erstellung einer Kontext von HttpRequestMessage:

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net.Http;
using System.Web;

using DevDefined.OAuth.Framework;

public class WebApiOAuthContextBuilder : OAuthContextBuilder
{
    public WebApiOAuthContextBuilder()
        : base(UriAdjuster)
    {
    }

    public IOAuthContext FromHttpRequest(HttpRequestMessage request)
    {
        var context = new OAuthContext
            {
                RawUri = this.CleanUri(request.RequestUri), 
                Cookies = this.CollectCookies(request), 
                Headers = ExtractHeaders(request), 
                RequestMethod = request.Method.ToString(), 
                QueryParameters = request.GetQueryNameValuePairs()
                    .ToNameValueCollection(), 
            };

        if (request.Content != null)
        {
            var contentResult = request.Content.ReadAsByteArrayAsync();
            context.RawContent = contentResult.Result;

            try
            {
                //the following line can result in a NullReferenceException
                var contentType = 
                    request.Content.Headers.ContentType.MediaType;
                context.RawContentType = contentType;

                if (contentType.ToLower()
                    .Contains("application/x-www-form-urlencoded"))
                {
                    var stringContentResult = request.Content
                        .ReadAsStringAsync();
                    context.FormEncodedParameters = 
                        HttpUtility.ParseQueryString(stringContentResult.Result);
                }
            }
            catch (NullReferenceException)
            {
            }
        }

        this.ParseAuthorizationHeader(context.Headers, context);

        return context;
    }

    protected static NameValueCollection ExtractHeaders(
        HttpRequestMessage request)
    {
        var result = new NameValueCollection();

        foreach (var header in request.Headers)
        {
            var values = header.Value.ToArray();
            var value = string.Empty;

            if (values.Length > 0)
            {
                value = values[0];
            }

            result.Add(header.Key, value);
        }

        return result;
    }

    protected NameValueCollection CollectCookies(
        HttpRequestMessage request)
    {
        IEnumerable<string> values;

        if (!request.Headers.TryGetValues("Set-Cookie", out values))
        {
            return new NameValueCollection();
        }

        var header = values.FirstOrDefault();

        return this.CollectCookiesFromHeaderString(header);
    }

    ///<summary>
    ///Adjust the URI to match the RFC specification (no query string!!).
    ///</summary>
    ///<param name="uri">
    ///The original URI. 
    ///</param>
    ///<returns>
    ///The adjusted URI. 
    ///</returns>
    private static Uri UriAdjuster(Uri uri)
    {
        return
            new Uri(
                string.Format(
                    "{0}://{1}{2}{3}", 
                    uri.Scheme, 
                    uri.Host, 
                    uri.IsDefaultPort ?
                        string.Empty :
                        string.Format(":{0}", uri.Port), 
                    uri.AbsolutePath));
    }
}

4) Verwenden Sie dieses tutorial, zum erstellen eines OAuth-Anbieter: http://code.google.com/p/devdefined-tools/wiki/OAuthProvider. Im letzten Schritt (Zugriff auf die Geschützte Ressource. B.) Sie können diesen code in Ihre AuthorizationFilterAttribute Attribut:

public override void OnAuthorization(HttpActionContext actionContext)
{
    //the only change I made is use the custom context builder from step 3:
    OAuthContext context = 
        new WebApiOAuthContextBuilder().FromHttpRequest(actionContext.Request);

    try
    {
        provider.AccessProtectedResourceRequest(context);

        //do nothing here
    }
    catch (OAuthException authEx)
    {
        //the OAuthException's Report property is of the type "OAuthProblemReport", it's ToString()
        //implementation is overloaded to return a problem report string as per
        //the error reporting OAuth extension: http://wiki.oauth.net/ProblemReporting
        actionContext.Response = new HttpResponseMessage(HttpStatusCode.Unauthorized)
            {
               RequestMessage = request, ReasonPhrase = authEx.Report.ToString()
            };
    }
}

Implementierte ich meinen eigenen provider, also habe ich noch nicht getestet der obige code (außer natürlich die WebApiOAuthContextBuilder die ich verwende in meinem provider) aber es sollte funktionieren.

InformationsquelleAutor Maksymilian Majer

Wenn Sie wollen, sichern Sie sich Ihren API in einer server-zu-server-Mode (keine Umleitung auf die website, für die 2-beinigen-Authentifizierung). Sie können sich bei OAuth2-Client Credentials Grant-Protokoll.

https://dev.twitter.com/docs/auth/application-only-auth

Entwickelt ich eine Bibliothek, die helfen können Sie problemlos hinzufügen diese Art von Unterstützung, um Ihre WebAPI. Sie können es als NuGet-Paket:

https://nuget.org/packages/OAuth2ClientCredentialsGrant/1.0.0.0

Die Bibliothek Ziele .NET Framework 4.5.

Sobald Sie das Paket hinzufügen zu Ihrem Projekt, wird es eine readme-Datei im Stammverzeichnis Ihres Projekts. Anschauen kann man sich das readme-Datei finden Sie unter konfigurieren/verwenden Sie dieses Paket.

Prost!

InformationsquelleAutor Varun Chatterji