web-dev-qa-db-fra.com

Authentification multiplateforme à l'aide de l'API Web ASP.NET

Comment puis-je même commencer à coder l'authentification à l'aide de l'API Web ASP.NET pour permettre la prise en charge multiplate-forme des ordinateurs de bureau, mobiles et Web? J'avais lu certaines méthodes d'authentification RESTful, telles que l'utilisation de jetons dans l'en-tête.

Existe-t-il des exemples de projets utilisant cette méthode? 

Des questions:

  1. Si ce n'est pas le cas, comment corriger l'attribut [Authorize] pour lire le jeton? 
  2. Comment générer ce jeton? Je ne pense pas que je puisse utiliser formsauthentication car des cookies sont utilisés.
  3. Comment gérer l'autorisation actuelle, le client envoie-t-il un mot de passe et un nom d'utilisateur bruts, puis-je générer le jeton ou existe-t-il un autre moyen?
  4. Comment puis-je gérer lorsque mon site Web l'utilise? J'ai entendu dire que la gestion était différente de celle utilisée par une application, par exemple l'obtention du domaine et son autorisation.
asp.net-mvcrestasp.net-web-api
50
Shawn Mclean

Je pense que les jetons seraient un bon moyen d’aller. L'authentification par formulaire est basée sur des cookies pour le Web. Pas la situation la plus idée pour tous les clients non-navigateur cependant. 

Ce que je suggérerais, c'est de créer un AuthorizationFilterAttribute personnalisé et de remplacer la méthode OnAuthorization. Avec cette méthode, vous pouvez vérifier l'existence d'un jeton que vous avez émis au client après avoir fourni des informations d'identification valides. Vous pouvez utiliser cet attribut sur n'importe quelle méthode ou contrôleur que vous souhaitez valider. Voici un exemple que vous pourriez citer

 public class AuthorizeTokenAttribute : AuthorizationFilterAttribute 
{      
    public override void OnAuthorization(HttpActionContext actionContext)
    {
        if (actionContext != null)
        {                
                if (!AuthorizeRequest(actionContext.ControllerContext.Request))
                {
                    actionContext.Response = new HttpResponseMessage(HttpStatusCode.Unauthorized) { RequestMessage = actionContext.ControllerContext.Request }; 
                }
                return;
        }
    }

    private bool AuthorizeRequest(System.Net.Http.HttpRequestMessage request)
    {
        bool authorized = false;
        if (request.Headers.Contains(Constants.TOKEN_HEADER))
        {               
            var tokenValue = request.Headers.GetValues("TOKEN_HEADER");
            if (tokenValue.Count() == 1) {
                var value = tokenValue.FirstOrDefault();               
               //Token validation logic here
               //set authorized variable accordingly
            }                
        }
        return authorized;
    } }

TOKEN_HEADER est simplement une chaîne représentant un en-tête HTTP que le client doit renvoyer pour les demandes authentifiées.

Alors parcourons-le

  1. Le client demande des données sécurisées
  2. Le client n'est pas autorisé, renvoie une réponse avec un code d'état Non autorisé.
  3. Le client envoie des informations d'identification pour s'authentifier, lesquelles doivent être sécurisées via HTTPS.
  4. Une fois validé, le client reçoit un jeton via un en-tête HTTP ou tout ce qui vous convient.
  5. Le client essaie à nouveau de demander des données sécurisées, cette fois, joint le jeton à la demande.
  6. AuthorizeTokenAttribute validera le jeton et autorisera l'exécution de l'action.

Aussi, vérifiez ce post par John Petersen. Sécuriser vos API Web ASP.NET

42
cecilphillip

Il existe de nombreuses façons d'authentifier les utilisateurs pour un service REST. Il est possible d’utiliser des jetons, mais l’utilisation de Authentification de base est encore plus simple et standard.

Ne confondez pas autorisation avec authentification . L'attribut [Autoriser] concerne uniquement l'autorisation, mais uniquement après qu'un utilisateur a été authentifié à l'aide d'un autre mécanisme. L'autorisation est totalement inutile sans une authentification correcte préalable.

La meilleure ressource à vérifier est Dominick Baier qui est un expert en la matière.

21
Maurice

J'utilise une approche très simple: 

  1. définir un profil d'accès avec ses identifiants unique accessId et accessKey (par exemple, valeur MD5 hachée GUID)
  2. stocker ce profil d'accès dans la base de données
  3. chaque requête (GET/POST/etc.) doit fournir accessId, queryHash (la valeur de hachage MD5 représente la requête) et la signature (valeur de hachage MD5 de queryHash + accessKey). Bien sûr, le client doit garder la clé AccessKey dans un endroit sûr !!!
  4. le serveur obtient la requête va vérifier l'identifiant d'accès et la signature en utilisant le même algorithme de calcul pour rejeter ou accorder l'accès (authentifier)
  5. une autorisation supplémentaire peut être effectuée sur la base du type de demande en utilisant le profil d'accès 

le service utilisant cette approche à l'aide de la nouvelle API Web ASP.NET MVC peut servir n'importe quel type de client: navigateur/javascript et natif (ordinateur de bureau ou mobile), etc.

2
user1344426

Vous pouvez utiliser ActionFilterAttribute et substituer la méthode OnActionExecuting . Plus tard, inscrivez ce filtre dans global.cs pour appliquer ce filtre à toutes les actions de ce type dans la méthode Application Start.

var config = GlobalConfiguration.Configuration; config.Filters.Add (new CustomAuthAttribute ());

{ namespace Customss { Classe publique CustomAuthAttribute: ActionFilterAttribute

{

    public override void OnActionExecuting(HttpActionContext actionContext)
    {
        // To inforce HTTPS if desired , else comment out the code
        if (!String.Equals(actionContext.Request.RequestUri.Scheme, "https", StringComparison.OrdinalIgnoreCase))
        {
            actionContext.Response = new HttpResponseMessage(System.Net.HttpStatusCode.BadRequest)
            {
                Content = new StringContent("HTTPS Required")
            };
            return;
        }

       // get toekn from the header

        var userToken = actionContext.Request.Headers.GetValues("UserToken");
         // Customer Logic to check the validity of the token.
        // U can have some DB logic to check , custom STS behind or some loca cache used to compare the values


    }


}

} }

0
Mian