MVC ASP.NET - Manuellement autoriser quelqu'un et à la persistance de l'autorisation par l'intermédiaire des Formulaires d'Authentification

Je veux les avantages de l'authentification par formulaire dans ASP.NET. Je veux qu'il persiste, l'autorisation pour moi et, mais il y a une chose de différent à propos de ma situation; je veux s'authentifier auprès d'un service web simple (plus précisément fournie par le client).

J'ai mon code à la place de regarder le lieu web et de voir si elles devrait être autorisé, mais comment puis-je définir le cookie[?] ou d'une autorisation de drapeau ASP.NET qu'ils savent de l'utilisateur en cours est autorisé.

Essentiellement...

if (HttpContext.Current.User.Identity.IsAuthenticated)
//we're all good

//Other wise...
bool success = CheckClientsWebService(string username, string password);

if (success)
//Somehow tell .NET that they're authorized

*Note: Ceci est assez simple service qui ne traite pas avec des groupes ou des rôles. Simplement de vérifier si un utilisateur est ok pour afficher le site.

Sonne comme vous avez besoin d'un fournisseur d'appartenances personnalisé qui vérifie l'authentification dans votre base de données et également dans le service web. C'est cependant une telle solution simple que je pense que je manque quelque chose d'important, sinon vous serait évidemment venir avec cette solution sur votre propre.
Je n'ai même pas besoin d'une base de données à vérifier, je suis simplement à la recherche à un service web et de voir si le nom d'utilisateur/mot de passe est correct. Juste besoin de savoir comment persister que l'utilisateur est "authentifié".
Vous devez créer votre propre fournisseur d'appartenances et d'émettre des cookies d'authentification de formulaires. C'est une norme des choses.
Puisque vous n'avez pas besoin de traiter avec des groupes ou des rôles, envisager de réglage manuel de la FormsAuthenticationCookie. Voir stackoverflow.com/questions/7524136/... pour plus de détails.

OriginalL'auteur contactmatt | 2012-08-30

Dans les formulaires d'authentification n'est pas la preuve de qui vous êtes dans le cookie d'authentification de formulaires.? Avec cela à l'esprit, ne pourrait-on pas créer le ticket personnalisé dans un formulaire de connexion, sans avoir à créer un fournisseur personnalisé? Je serait certainement penser que vous pourriez. Faites un test rapide et de créer des formulaires de ticket d'authentification et de voir si la sortie de la box du fournisseur d'appartenances considère que l'utilisateur authentifié.

J'étais curieux de savoir-- donc, voici un peu de code..

Modèle

public class SignInViewModel
{
    public string Username { get; set; }
    public string Password { get; set; }
}

Contrôleur

public class SignInController : Controller
{

    public ActionResult Index()
    {
        var model = new SignInViewModel {};
        return View(model);
    }

    [HttpPost]
    public ActionResult Index(SignInViewModel model)
    {
        if (model.Username == "Fred" && model.Password == "Mertz")
        {
            FormsAuthentication.SetAuthCookie(model.Username, false);
            return RedirectToAction("Secure");
        }
        return View(model);
    }

    [Authorize]
    public ActionResult Secure(SignInViewModel model)
    {
        return View();
    }

    [Authorize]
    public ActionResult Logout(SignInViewModel model)
    {
        FormsAuthentication.SignOut();
        return RedirectToAction("Index");
    }

Index.cshtml

@using (Html.BeginForm()) {
    <fieldset>
        <legend>SignInViewModel</legend>

        <div class="editor-label">
            @Html.LabelFor(model => model.Username)
        </div>
        <div class="editor-field">
            @Html.EditorFor(model => model.Username)
            @Html.ValidationMessageFor(model => model.Username)
        </div>

        <div class="editor-label">
            @Html.LabelFor(model => model.Password)
        </div>
        <div class="editor-field">
            @Html.EditorFor(model => model.Password)
            @Html.ValidationMessageFor(model => model.Password)
        </div>

        <p>
            <input type="submit" value="Login" />
        </p>
    </fieldset>
}

Sécurisé.cshtml

<h2>Secure</h2>
@Html.ActionLink("Logout", "Logout")

Salut, FormsAuthentication.SetAuthCookie(modèle.Nom d'utilisateur, false); ne fonctionne pas pour moi. Je suis en utilisant MVC 5
êtes-vous en utilisant le Système.Web.La sécurité de l'espace de noms? Il doit être pris en charge dans MVC5 / ASP.NET 4.5+ msdn.microsoft.com/en-us/library/...
MVC 5 ASP.NET l'Identité est activé par défaut, ce qui désactive FormsAuthentication.

OriginalL'auteur ek_ny

6

J'ai peut-être plus de la simplification, mais la façon dont je lis ceci est la suivante:
1. Si un utilisateur n'est pas authentifié, vous disposez d'un formulaire que vous collectez le nom d'utilisateur/mot de passe
2. Les résultats de ce formulaire sont transmises à un service web pour l'autorisation
3. Si cette autorisation est réussie, vous avez besoin d'un moyen de laisser l'application web savent qu'ils ont signés.
4. Si ils sont authentifiés, faire des trucs
Si ce qui précède est correct, vous n'avez pas besoin d'un fournisseur d'appartenances. L'attribut [Authorize] regarde simplement que le cookie d'authentification de formulaires pour voir si elle a été définie et est valide pour la durée de vie du cookie. Ce cookie d'authentification stocke le nom d'utilisateur de l'utilisateur et la date d'expiration du cookie (et d'autres trucs, mais pas important ici).

Étant donné que, vous avez seulement besoin de mettre votre site web.config configuration de l'élément et de disposer d'une méthode pour définir le cookie d'authentification.

Web.Config
```
<system.web>
    <authentication mode="Forms">
      <forms loginUrl="~/Account/LogOn" timeout="2880" />
    </authentication>
</system.web>
```
URL de connexion de l'OBTENIR d'action
```
public ActionResult Logon(){
   //if the user is logged in, send the to the home page
   if(httpContext.User.Identity.IsAuthenticated_{
        Return RedirectToAction("Index", "Home");
   }
   Return this.View(new LoginViewModel());
}
```
URL de connexion de l'action POST
```
[HttpPost]
public ActionResult Logon(LoginViewModel model){
   //Check for model errors
   if(!ModelState.IsValid()){
       Return this.View(model);
   }

   //Validate against web service - return error if false
   if(!CheckClientsWebService(model.UserName, model.Password)){
       ModelState.AddModelError("","The username or password is invalid");
       Return this.View(model);
   } 

   //Manually set the authentication cookie
   FormsAuthentication.SetAuthCookie(model.UserName, model.RememberMe);  
   //Send them on to the home page, they now have a authorization cookie
   Return RedirectToAction("Index", "Home");
}
```
Une fois que vous avez appelé le .SetAuthCookie() fonction, l'utilisateur aura désormais un ticket d'authentification et d'appels à la HttpContext.User.Identity.IsAuthenticated sera vrai tant que le cookie n'a pas expiré et vous pouvez obtenir le nom d'utilisateur de HttpContext.User.Identity.Name

OriginalL'auteur Tommy
0

Comme Wiktor commenté, mettre en place votre propre MembershipProvider. Mettre en œuvre les méthodes que vous avez besoin, laissez le reste à jeter un NotImplementedException.

Dans votre cas, ça ressemble à tout ce que vous devez mettre en œuvre est public bool ValidateUser(string username, string password) - dont la mise en œuvre juste besoin de faire appel à votre webservice.

Ensuite, vous pouvez utiliser tous les standard intégré dans l'authentification et l'autorisation des trucs.

OriginalL'auteur StanK

Vous devez vous connecter pour publier un commentaire.