ASP.net MVC - defina IIdentity personalizado ou IPrincipal

Preciso fazer algo bastante simples: no meu aplicativo ASP.NET MVC, quero definir um IIdentity / IPrincipal personalizado. O que for mais fácil / mais adequado. Eu quero estender o padrão para que eu possa chamar algo como User.Identity.Ide User.Identity.Role. Nada extravagante, apenas algumas propriedades extras.

Eu li vários artigos e perguntas, mas sinto que estou dificultando o que realmente é. Eu pensei que seria fácil. Se um usuário fizer logon, desejo definir uma identidade II personalizada. Então eu pensei, vou implementar Application_PostAuthenticateRequestno meu global.asax. No entanto, isso é chamado em todas as solicitações, e eu não quero fazer uma chamada ao banco de dados em todas as solicitações que solicitariam todos os dados do banco de dados e colocassem um objeto IPrincipal personalizado. Isso também parece muito desnecessário, lento e no lugar errado (fazendo chamadas de banco de dados lá), mas eu posso estar errado. Ou de onde mais esses dados viriam?

Por isso, pensei que, sempre que um usuário efetua login, posso adicionar algumas variáveis ​​necessárias em minha sessão, adicionadas à IIdentity personalizada no Application_PostAuthenticateRequestmanipulador de eventos. No entanto, o meu Context.Sessionestá nulllá, de modo que também não é o caminho a percorrer.

Estou trabalhando nisso há um dia e sinto que estou perdendo alguma coisa. Isso não deve ser muito difícil de fazer, certo? Também estou um pouco confuso com todas as coisas (semi) relacionadas que acompanham isso. MembershipProvider, MembershipUser, RoleProvider, ProfileProvider, IPrincipal, IIdentity, FormsAuthentication.... Eu sou o único que acha tudo isso muito confuso?

Se alguém pudesse me dizer uma solução simples, elegante e eficiente para armazenar alguns dados extras em uma identidade sem todo o fuzz extra ... isso seria ótimo! Eu sei que existem perguntas semelhantes no SO, mas se a resposta que eu preciso está aí, eu devo ter esquecido.

Aqui está como eu faço isso.

Decidi usar o IPrincipal em vez do IIdentity porque significa que não preciso implementar o IIdentity e o IPrincipal.

1. Crie a interface

   interface ICustomPrincipal : IPrincipal
   {
       int Id { get; set; }
       string FirstName { get; set; }
       string LastName { get; set; }
   }

2. CustomPrincipal

   public class CustomPrincipal : ICustomPrincipal
   {
       public IIdentity Identity { get; private set; }
       public bool IsInRole(string role) { return false; }
   
       public CustomPrincipal(string email)
       {
           this.Identity = new GenericIdentity(email);
       }
   
       public int Id { get; set; }
       public string FirstName { get; set; }
       public string LastName { get; set; }
   }

3. CustomPrincipalSerializeModel - para serializar informações personalizadas no campo de dados do usuário no objeto FormsAuthenticationTicket.

   public class CustomPrincipalSerializeModel
   {
       public int Id { get; set; }
       public string FirstName { get; set; }
       public string LastName { get; set; }
   }

4. Método de logon - configurando um cookie com informações personalizadas

   if (Membership.ValidateUser(viewModel.Email, viewModel.Password))
   {
       var user = userRepository.Users.Where(u => u.Email == viewModel.Email).First();
   
       CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
       serializeModel.Id = user.Id;
       serializeModel.FirstName = user.FirstName;
       serializeModel.LastName = user.LastName;
   
       JavaScriptSerializer serializer = new JavaScriptSerializer();
   
       string userData = serializer.Serialize(serializeModel);
   
       FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
                1,
                viewModel.Email,
                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 RedirectToAction("Index", "Home");
   }

5. Global.asax.cs - Lendo o cookie e substituindo o objeto HttpContext.User, isso é feito substituindo PostAuthenticateRequest

   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();
   
           CustomPrincipalSerializeModel serializeModel = serializer.Deserialize<CustomPrincipalSerializeModel>(authTicket.UserData);
   
           CustomPrincipal newUser = new CustomPrincipal(authTicket.Name);
           newUser.Id = serializeModel.Id;
           newUser.FirstName = serializeModel.FirstName;
           newUser.LastName = serializeModel.LastName;
   
           HttpContext.Current.User = newUser;
       }
   }

6. Acesso às visualizações do Razor

   @((User as CustomPrincipal).Id)
   @((User as CustomPrincipal).FirstName)
   @((User as CustomPrincipal).LastName)

e no código:

    (User as CustomPrincipal).Id
    (User as CustomPrincipal).FirstName
    (User as CustomPrincipal).LastName

Eu acho que o código é auto-explicativo. Se não for, me avise.

Além disso, para tornar o acesso ainda mais fácil, você pode criar um controlador base e substituir o objeto Usuário retornado (HttpContext.User):

public class BaseController : Controller
{
    protected virtual new CustomPrincipal User
    {
        get { return HttpContext.User as CustomPrincipal; }
    }
}

e depois, para cada controlador:

public class AccountController : BaseController
{
    // ...
}

que permitirá acessar campos personalizados em códigos como este:

User.Id
User.FirstName
User.LastName

Mas isso não funcionará dentro das visualizações. Para isso, você precisará criar uma implementação personalizada do WebViewPage:

public abstract class BaseViewPage : WebViewPage
{
    public virtual new CustomPrincipal User
    {
        get { return base.User as CustomPrincipal; }
    }
}

public abstract class BaseViewPage<TModel> : WebViewPage<TModel>
{
    public virtual new CustomPrincipal User
    {
        get { return base.User as CustomPrincipal; }
    }
}

Crie um tipo de página padrão em Views / web.config:

<pages pageBaseType="Your.Namespace.BaseViewPage">
  <namespaces>
    <add namespace="System.Web.Mvc" />
    <add namespace="System.Web.Mvc.Ajax" />
    <add namespace="System.Web.Mvc.Html" />
    <add namespace="System.Web.Routing" />
  </namespaces>
</pages>

e nas visualizações, você pode acessá-lo assim:

@User.FirstName
@User.LastName

Não posso falar diretamente para o ASP.NET MVC, mas para o ASP.NET Web Forms, o truque é criar FormsAuthenticationTickete criptografá-lo em um cookie depois que o usuário for autenticado. Dessa forma, você só precisa chamar o banco de dados uma vez (ou o AD ou o que estiver usando para executar sua autenticação) e cada solicitação subsequente será autenticada com base no ticket armazenado no cookie.

Um bom artigo sobre isso: http://www.ondotnet.com/pub/a/dotnet/2004/02/02/effectiveformsauth.html (link quebrado)

Editar:

Como o link acima está quebrado, eu recomendaria a solução de LukeP em sua resposta acima: https://stackoverflow.com/a/10524305 - Eu também sugeriria que a resposta aceita fosse alterada para essa.

Edição 2: Uma alternativa para o link quebrado: https://web.archive.org/web/20120422011422/http://ondotnet.com/pub/a/dotnet/2004/02/02/effectiveformsauth.html

Aqui está um exemplo para fazer o trabalho. O bool isValid é definido olhando para algum armazenamento de dados (digamos, sua base de dados do usuário). UserID é apenas um ID que estou mantendo. Você pode adicionar informações adicionais, como endereço de email, aos dados do usuário.

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);
     }
}

no golax asax, adicione o seguinte código para recuperar suas informações

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;
    }
}

Quando você usar as informações posteriormente, poderá acessar seu principal personalizado da seguinte maneira.

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

isso permitirá que você acesse informações personalizadas do usuário.

O MVC fornece o método OnAuthorize que trava nas suas classes de controlador. Ou você pode usar um filtro de ação personalizado para executar a autorização. O MVC facilita bastante a execução. Eu publiquei um post sobre isso aqui. http://www.bradygaster.com/post/custom-authentication-with-mvc-3.0

Aqui está uma solução se você precisar conectar alguns métodos ao @User para usar em suas visualizações. Nenhuma solução para qualquer personalização séria de associação, mas se a pergunta original fosse necessária apenas para visualizações, talvez isso fosse suficiente. O abaixo foi usado para verificar uma variável retornada de um filtro de autor, usada para verificar se alguns links devem ser apresentados ou não (não para qualquer tipo de lógica de autorização ou concessão de acesso).

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
            }
        }
    }

Em seguida, basta adicionar uma referência nas áreas web.config e chamá-la como abaixo na exibição.

@User.IsEditor()

Baseado em resposta de LukeP , adicione alguns métodos para configurar timeoute requireSSLcolaborar Web.config.

Os links de referências

• MSDN, Explained: Autenticação de Formulários no ASP.NET 2.0
• MSDN, classe FormsAuthentication
• SO, valor de tempo limite de autenticação de formulários de acesso .net no código

Códigos modificados de LukeP

1, definido com timeoutbase Web.Config. O FormsAuthentication.Timeout obterá o valor do tempo limite, definido em web.config. Embrulhei o seguinte para ser uma função, que retorna uma ticketvolta.

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, Configure o cookie para ser seguro ou não, com base na RequireSSLconfiguração.

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

Tudo bem, então eu sou um cryptkeeper sério arrastando essa pergunta muito antiga, mas há uma abordagem muito mais simples disso, que foi abordada por @Baserz acima. E isso é usar uma combinação de métodos de extensão C # e cache (NÃO use session).

De fato, a Microsoft já forneceu várias dessas extensões no Microsoft.AspNet.Identity.IdentityExtensionsespaço para nome. Por exemplo, GetUserId()é um método de extensão que retorna o ID do usuário. Há também GetUserName()eFindFirstValue() , que retorna declarações com base no IPrincipal.

Então você só precisa incluir o espaço para nome e chamar User.Identity.GetUserName() para obter o nome de usuário conforme configurado pela identidade do ASP.NET.

Não tenho certeza se isso está em cache, pois a antiga identidade do ASP.NET não é de código aberto e não me preocupei em fazer a engenharia reversa. No entanto, se não for, você poderá escrever seu próprio método de extensão, que armazenará esse resultado em cache por um período específico de tempo.

Como um complemento ao código LukeP para usuários de Web Forms (não MVC), se você deseja simplificar o acesso no código por trás de suas páginas, basta adicionar o código abaixo a uma página base e derivar a página base em todas as suas páginas:

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

Portanto, no seu código por trás, você pode simplesmente acessar:

User.FirstName or User.LastName

O que estou perdendo em um cenário de formulário da Web é como obter o mesmo comportamento no código não vinculado à página, por exemplo, em httpmodules , devo sempre adicionar uma em cada classe ou existe uma maneira mais inteligente de obter isso?

Obrigado por suas respostas e agradecer a LukeP desde que eu usei seus exemplos como base para o meu usuário personalizada (que agora tem User.Roles, User.Tasks, User.HasPath(int), User.Settings.Timeoute muitas outras coisas boas)

Tentei a solução sugerida por LukeP e constatei que ela não suporta o atributo Autorizar. Então, eu modifiquei um pouco.

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);
    }

E finalmente em 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;
        }
    }

Agora eu posso acessar os dados em visualizações e controladores simplesmente chamando

User.ExInfo()

Para sair, eu ligo

AuthManager.SignOut();

onde AuthManager é

HttpContext.GetOwinContext().Authentication