Comment mettre en œuvre les contrôles d'autorisation dans ASP.NET MVC basé sur les données de Session?

Ce sera mon premier ASP.NET application MVC avec l'authentification par formulaires, alors j'essaie de m'assurer de ne rien manquer. Le scénario est le suivant: Public /Zones Sécurisées.

Au sein de l'espace privé, il est encore limitée à des domaines spécifiques ou de l'utilisateur. Ces "Régions" sont définis par des personnalisations à la superficie de base qui sont personnalisés par groupe d'utilisateurs.

Ainsi, par exemple, un utilisateur peut obtenir l'url /Area/Controller/Action. Ils auraient besoin d'avoir la permission de la zone protégée, ou ils sont redirigés vers le signe-dans la vue.

J'ai lu sur le AuthorizeAttribute mais je ne suis pas sûr de savoir comment/où je devrais être en train de faire ces vérifications de base. Ma première intuition serait de stocker un objet utilisateur dans la session, après avoir réussi à vous connecter avec l'IP de l'utilisateur et les détails à propos de ce qu'ils ont accès à l'etc.

Le contrôle des autorisations pour chaque garantis contrôleur de l'appel serait de vérifier qu'un utilisateur valide de l'objet existe dans la session, l'IPs toujours correspondre, et l'utilisateur a accès à la zone spécifique. Est-il évident trous de cette installation?

Edit: Où/comment puis-je mettre en œuvre ces contrôles, de sorte que quand un contrôleur est taggés avec [Autoriser], il va effectuer ceux de la session de l'objet de contrôles?

Tous les pointeurs ou les suggestions seront très appréciés. Merci.

OriginalL'auteur Kelsey | 2009-07-20

  1. 11

    Bien on dirait que je suis allé avec un AuthorizeAttribute personnalisé. Il était en fait très simple. Voici le code:

    namespace MyApp.Custom.Security
{
    public class Secure : AuthorizeAttribute
    {
        ///<summary>
        ///Checks to see if the user is authenticated and has a valid session object
        ///</summary>        
        ///<param name="httpContext"></param>
        ///<returns></returns>
        protected override bool AuthorizeCore(HttpContextBase httpContext)
        {
            if (httpContext == null) throw new ArgumentNullException("httpContext");

            //Make sure the user is authenticated.
            if (httpContext.User.Identity.IsAuthenticated == false) return false;

            //This will check my session variable and a few other things.
            return Helpers.SecurityHelper.IsSignedIn();
        }
    }
}

    Puis sur mon contrôleurs, j'ai juste à mettre un [Secure] attribut et il utilise ma fonction ci-dessus à tout moment le contrôleur est accessible. Assez simple. J'ai aussi fait un [SecureByRole] attribut ainsi que le fait tous la même chose, mais vérifie mon rôle personnalisé de l'information. Pas besoin de tout ce qui construit en vaudou de la conserve de l'Adhésion 🙂

    OriginalL'auteur Kelsey

  2. 2

    Essayez de regarder à l' RoleProvider classe. C'est la structure de base de la façon dont ASP.net utiliser basée sur les rôles d'autorisation pour les utilisateurs. Et je pense que vous devriez utiliser [Autoriser(Rôles='...')] attribut à utiliser.

    Je suis en train d'essayer de rester loin de la boulangerie dans le rôle de la solution si possible. Vous ne savez pas comment personnalisables, il est.
    nan.. le roleprovider est la classe de base que vous devrait/pourrait mettre en place votre propre personnalisation. Pour commencer rôle personnalisé autorisation, vous venez de prolonger la roleprovider de classe et de modifier le site web.fichier de configuration pour l'en informer.

    OriginalL'auteur xandy

  3. 1

    Dans mon précédent application j'ai utilisé un simple HttpModule pour augmenter l'utilisateur authentifié avec des rôles supplémentaires etc ( je l'ai fait parce que mes exigences étaient très limitées ).

    public class AuthorisationModule : IHttpModule
{
    public void Init( HttpApplication context )
    {
        context.AuthorizeRequest += AuthorizeRequest;
    }

    private void AuthorizeRequest(object sender, EventArgs e)
    {
        var currentUser = HttpContext.Current.User;
        if( !currentUser.IsAuthenticated() )
        {
            return;
        }

        var roles = new List<string>();
        //Add roles here using whatever logic is required

        var principal = new GenericPrincipal( currentUser.Identity, roles.ToArray() );
        HttpContext.Current.User = principal;
    }

    public void Dispose()
    {
        if(HttpContext.Current == null )
        {
            return;
        }

        if(HttpContext.Current.ApplicationInstance == null)
        {
            return;
        }

        HttpContext.Current.ApplicationInstance.AuthorizeRequest -= AuthorizeRequest;
    }
}

    OriginalL'auteur Neal

  4. 1
    [Authorize]
public class BaseController : Controller
{
protected override void OnAuthorization(AuthorizationContext authContext)
{
if
(
!User.Identity.IsAuthenticated &&
Request.LogonUserIdentity != null &&
Request.LogonUserIdentity.IsAuthenticated
)
{
var logonUserIdentity = Request.LogonUserIdentity.Name;
if (!string.IsNullOrEmpty(logonUserIdentity))
{
if (logonUserIdentity.Contains("\\"))
logonUserIdentity = logonUserIdentity.Substring(logonUserIdentity.IndexOf("\\") + 1);
var db = new UsersContext();
var loginUser =
db.UserProfiles.FirstOrDefault(x => x.UserName == logonUserIdentity);
//Auto-Login Windows Identity
if (loginUser == null)
loginUser = CreateUser(db, logonUserIdentity);
if (loginUser != null)
{
FormsAuthentication.SetAuthCookie(loginUser.UserName, true);
string returnUrl = Request.RawUrl;
if (!string.IsNullOrEmpty(returnUrl))
Response.Redirect(returnUrl);
Response.Redirect("~/");
}
}
}
}
private static UserProfile CreateUser(UsersContext db, string logonUserIdentity)
{
var user = new UserProfile {UserName = logonUserIdentity};
db.UserProfiles.Add(user);
db.SaveChanges();
return user;
}
}

    OriginalL'auteur Tawani