ASP.NET MVC-Set custom IIdentity or principal

Je ne peux pas parler directement pour ASP.NET MVC, mais pour ASP.NET formulaires Web, le truc est de créer un FormsAuthenticationTicket et de le chiffrer dans un cookie une fois que l'Utilisateur a été authentifié. De cette façon, vous n'avez qu'à appeler la base de données qu'une seule fois (ou une seule annonce publicitaire ou tout ce que vous utilisez pour effectuer votre authentification), et chaque requête subséquente s'authentifiera sur la base du ticket stocké dans le cookie.

un bon article sur ceci: http://www.ondotnet.com/pub/a/dotnet/2004/02/02/effectiveformsauth.html (lien brisé)

Edit:

puisque le lien ci-dessus est cassé, je recommande la solution de LukeP dans sa réponse ci-dessus: https://stackoverflow.com/a/10524305 - je suggérerais également que la réponse acceptée soit remplacée par celle-ci.

Edit 2: Un alternative pour le lien brisé: https://web.archive.org/web/20120422011422/http://ondotnet.com/pub/a/dotnet/2004/02/02/effectiveformsauth.html

Voici un exemple pour faire le travail. bool isValid est défini en regardant quelques données de magasin (disons votre base de données d'utilisateur). UserID est juste une identification que je maintiens. Vous pouvez ajouter des informations supplémentaires comme l'adresse e-mail aux données de l'utilisateur.

protected void btnLogin_Click(object sender, EventArgs e)
{         
    //Hard Coded for the moment
    bool isValid=true;
    if (isValid) 
    {
         string userData = String.Empty;
         userData = userData + "UserID=" + userID;
         FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(1, username, DateTime.Now, DateTime.Now.AddMinutes(30), true, userData);
         string encTicket = FormsAuthentication.Encrypt(ticket);
         HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
         Response.Cookies.Add(faCookie);
         //And send the user where they were heading
         string redirectUrl = FormsAuthentication.GetRedirectUrl(username, false);
         Response.Redirect(redirectUrl);
     }
}

dans le golbal asax ajouter le code suivant pour récupérer vos informations

protected void Application_AuthenticateRequest(Object sender, EventArgs e)
{
    HttpCookie authCookie = Request.Cookies[
             FormsAuthentication.FormsCookieName];
    if(authCookie != null)
    {
        //Extract the forms authentication cookie
        FormsAuthenticationTicket authTicket = 
               FormsAuthentication.Decrypt(authCookie.Value);
        // Create an Identity object
        //CustomIdentity implements System.Web.Security.IIdentity
        CustomIdentity id = GetUserIdentity(authTicket.Name);
        //CustomPrincipal implements System.Web.Security.IPrincipal
        CustomPrincipal newUser = new CustomPrincipal();
        Context.User = newUser;
    }
}

lorsque vous allez utiliser l'information plus tard, vous pouvez accéder à votre principal personnalisé comme suit.

(CustomPrincipal)this.User
or 
(CustomPrincipal)this.Context.User

cela vous permettra d'accéder aux informations personnalisées de l'utilisateur.

MVC vous fournit la méthode Onauthorizate qui tient de vos classes de contrôleur. Ou, vous pouvez utiliser un filtre d'action personnalisé pour effectuer l'autorisation. MVC le rend assez facile à faire. J'ai posté un billet de blog à ce sujet ici. http://www.bradygaster.com/post/custom-authentication-with-mvc-3.0

Voici une solution si vous avez besoin de raccorder certaines méthodes à @User pour une utilisation dans vos vues. Il n'y a pas de solution pour toute personnalisation sérieuse de l'adhésion, mais si la question initiale était nécessaire pour les vues uniquement, alors cela serait peut-être suffisant. Ce qui suit a été utilisé pour vérifier une variable retournée par un authorizefilter, utilisé pour vérifier si certains liens wehere to be presented ou non(pas pour tout type de logique d'autorisation ou d'octroi d'accès).

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Security.Principal;

    namespace SomeSite.Web.Helpers
    {
        public static class UserHelpers
        {
            public static bool IsEditor(this IPrincipal user)
            {
                return null; //Do some stuff
            }
        }
    }

alors il suffit d'ajouter une référence dans les domaines du web.config, et de l'appeler comme ci-dessous dans la vue.

@User.IsEditor()

basé sur la réponse de LukeP , et ajouter quelques méthodes pour configurer timeout et requireSSL a coopéré avec Web.config .

Les références des liens

• MSDN, expliqué: formulaires authentification en ASP.NET 2,0
• MSDN, FormsAuthentication Class
• DONC .net Accéder à des Formulaires authentification "timeout" valeur du code

Codes modifiés de LukeP

1, Réglez timeout basé sur Web.Config . Le FormsAuthentication.Timeout obtiendra la valeur timeout, qui est définie dans web.config. J'ai enveloppé les suivants pour être une fonction qui retourne un ticket en arrière.

int version = 1;
DateTime now = DateTime.Now;

// respect to the `timeout` in Web.config.
TimeSpan timeout = FormsAuthentication.Timeout;
DateTime expire = now.Add(timeout);
bool isPersist = false;

FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(
     version,          
     name,
     now,
     expire,
     isPersist,
     userData);

2, Configurer le cookie pour qu'il soit sécurisé ou non, sur la base de la configuration RequireSSL .

HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
// respect to `RequreSSL` in `Web.Config`
bool bSSL = FormsAuthentication.RequireSSL;
faCookie.Secure = bSSL;

D'accord, donc je suis un cryptkeeper sérieux ici en soulevant cette très vieille question, mais il y a une approche beaucoup plus simple à cela, qui a été abordée par @Baserz ci-dessus. Et c'est d'utiliser une combinaison de méthodes D'Extension C# et de cache (N'utilisez pas session).

en fait, Microsoft a déjà fourni un certain nombre de ces extensions dans l'espace de noms Microsoft.AspNet.Identity.IdentityExtensions . Par exemple, GetUserId() est une méthode d'extension qui retourne Id d'utilisateur. Il y a aussi GetUserName() et FindFirstValue() , qui renvoie des revendications fondées sur le principe.

donc vous n'avez besoin que d'inclure l'espace de noms, puis d'appeler User.Identity.GetUserName() pour obtenir le nom d'utilisateur tel que configuré par ASP.NET identité.

ASP.NET L'identité n'est pas de source ouverte, et je n'ai pas pris la peine de la rétro-ingénierie. Cependant, si c'est non, alors vous pouvez écrire votre propre méthode d'extension, qui sera cache ce résultat pour une période de temps spécifique.

comme ajout au Code LukeP pour les utilisateurs de formulaires Web (pas MVC) si vous voulez simplifier l'accès dans le code derrière vos pages, il suffit d'ajouter le code ci-dessous à une page de base et dériver la page de base dans toutes vos pages:

Public Overridable Shadows ReadOnly Property User() As CustomPrincipal
    Get
        Return DirectCast(MyBase.User, CustomPrincipal)
    End Get
End Property

ainsi dans votre code derrière vous pouvez simplement accéder:

User.FirstName or User.LastName

ce que je manque dans un scénario de formulaire Web, c'est comment obtenir le même comportement en code non lié à la page, par exemple dans httpmodules dois-je toujours ajouter un plâtre dans chaque classe ou y a-t-il un moyen plus intelligent d'obtenir cela?

Merci pour vos réponses et merci à LukeP depuis que j'ai utilisé vos exemples comme une base pour mon utilisateur personnalisée (qui a maintenant User.Roles , User.Tasks , User.HasPath(int) , User.Settings.Timeout et beaucoup d'autres belles choses)

j'ai essayé la solution suggérée par LukeP et j'ai trouvé qu'elle ne supporte pas L'attribut Authorize. Donc, je l'ai modifiée un peu.

public class UserExBusinessInfo
{
    public int BusinessID { get; set; }
    public string Name { get; set; }
}

public class UserExInfo
{
    public IEnumerable<UserExBusinessInfo> BusinessInfo { get; set; }
    public int? CurrentBusinessID { get; set; }
}

public class PrincipalEx : ClaimsPrincipal
{
    private readonly UserExInfo userExInfo;
    public UserExInfo UserExInfo => userExInfo;

    public PrincipalEx(IPrincipal baseModel, UserExInfo userExInfo)
        : base(baseModel)
    {
        this.userExInfo = userExInfo;
    }
}

public class PrincipalExSerializeModel
{
    public UserExInfo UserExInfo { get; set; }
}

public static class IPrincipalHelpers
{
    public static UserExInfo ExInfo(this IPrincipal @this) => (@this as PrincipalEx)?.UserExInfo;
}


    [HttpPost]
    [AllowAnonymous]
    [ValidateAntiForgeryToken]
    public async Task<ActionResult> Login(LoginModel details, string returnUrl)
    {
        if (ModelState.IsValid)
        {
            AppUser user = await UserManager.FindAsync(details.Name, details.Password);

            if (user == null)
            {
                ModelState.AddModelError("", "Invalid name or password.");
            }
            else
            {
                ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
                AuthManager.SignOut();
                AuthManager.SignIn(new AuthenticationProperties { IsPersistent = false }, ident);

                user.LastLoginDate = DateTime.UtcNow;
                await UserManager.UpdateAsync(user);

                PrincipalExSerializeModel serializeModel = new PrincipalExSerializeModel();
                serializeModel.UserExInfo = new UserExInfo()
                {
                    BusinessInfo = await
                        db.Businesses
                        .Where(b => user.Id.Equals(b.AspNetUserID))
                        .Select(b => new UserExBusinessInfo { BusinessID = b.BusinessID, Name = b.Name })
                        .ToListAsync()
                };

                JavaScriptSerializer serializer = new JavaScriptSerializer();

                string userData = serializer.Serialize(serializeModel);

                FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
                         1,
                         details.Name,
                         DateTime.Now,
                         DateTime.Now.AddMinutes(15),
                         false,
                         userData);

                string encTicket = FormsAuthentication.Encrypt(authTicket);
                HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
                Response.Cookies.Add(faCookie);

                return RedirectToLocal(returnUrl);
            }
        }
        return View(details);
    }

et enfin dans Global.asax.cs

    protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
    {
        HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];

        if (authCookie != null)
        {
            FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            PrincipalExSerializeModel serializeModel = serializer.Deserialize<PrincipalExSerializeModel>(authTicket.UserData);
            PrincipalEx newUser = new PrincipalEx(HttpContext.Current.User, serializeModel.UserExInfo);
            HttpContext.Current.User = newUser;
        }
    }

maintenant je peux accéder aux données dans les vues et les contrôleurs simplement en appelant

User.ExInfo()

pour me déconnecter je viens d'appeler

AuthManager.SignOut();

où AuthManager est

HttpContext.GetOwinContext().Authentication