Gestione della sicurezza del livello di entità/entità in un'applicazione ASP.NET MVC

Question

Che cosa fanno tutti per gestire la sicurezza (recupero e modifica) dei singoli record in un'applicazione ASP.NET MVC? Questa applicazione ha un livello Service/Business e un livello di accesso ai dati completamente separati dall'interfaccia utente Web. Sto già utilizzando i provider di appartenenze e ruoli per gestire l'autenticazione e l'autorizzazione per aree/funzionalità specifiche nella mia applicazione, ma ora ho bisogno di proteggere singoli record.

Ad esempio, dire che Bob può creare e modificare i propri record FooBar. Voglio assicurarmi che gli altri utenti non possano visualizzare o modificare i record di Bob. Voglio proteggermi dalla manipolazione degli URL e/o dagli errori di programmazione. Potremmo anche voler consentire a Bob di condividere i suoi FooBar con altri utenti, consentendo loro di visualizzare ma non modificare i suoi record.

Ci sono diversi approcci sono venuto su con:

• fare i controlli di sicurezza nello strato di accesso ai dati, direttamente nel recupero e modifica le query.
• Controllare la sicurezza nel livello di servizio, eseguire query di sicurezza aggiuntive prima di procedere con la logica aziendale.
• Creare un livello di sicurezza esistente tra l'interfaccia utente e il livello di servizio. L'interfaccia utente farebbe tutte le richieste attraverso il livello di sicurezza.
• Utilizzare la programmazione orientata agli aspetti (AOP). Creare aspetti di sicurezza e decorare i metodi del livello di servizio con gli attributi di sicurezza.

Ho eseguito la protezione nel livello di accesso ai dati (nelle query) nei progetti precedenti e si trasforma sempre in un pasticcio. Mi piacerebbe sapere cosa stanno facendo gli altri e quali sono le strutture che state usando per aiutarvi (framework AOP)

Answer 1

Io prendo sempre il 2o e/o il 3 ° dei vostri approcci - un livello di sicurezza esplicito da qualche parte tra l'interfaccia utente e gestori logici.

AOP suona come un modo per perdere completamente il controllo sul codice e la sicurezza in DAL suona come un approccio errato in quanto mescola diverse responsabilità.

Answer 2

Penso che mettere la logica ovunque sia un problema. Sto avendo una situazione simile. Lascia che ti spieghi come lo sto gestendo.

public class FooBarController : Controller 
{ 

    //this is easy as compared to edit 
    [Authorized] 
    public ActionResult Create() 
    { 


    } 


    [AjaxAuthorize(Roles = "Administrator")]  
    public ActionResult Edit(int id) 
    { 


    } 
} 

public class AjaxAuthorizeAttribute : AuthorizeAttribute 
{ 
    public override void OnAuthorization(AuthorizationContext filterContext) 
    { 


     var id = filterContext.RouteData.Values["id"]; 
     // Here you can check if the id belongs to logged in user 
     var content = SomeRepository.GetById(id); 
     if (contet.OwnerId=LoggedInUser.Id) 
      return; 

     //otherwise check if logged in user is from some Admin or other role. 


     string redirectPage = "/account/logon"; 
     var roles = base.Roles.Trim().Split(','); 
     bool CanAccess = false; 

     //If no role is there 
     if (base.Roles.Equals(string.Empty) || roles.Count() == 0) 
     { 
      CanAccess = true; 
     } 
     else 
     { 
      foreach (var item in roles) 
      { 
       CanAccess = filterContext.HttpContext.User.IsInRole(item); 
       if (CanAccess) 
        break; 
      } 
     } 

     var request = filterContext.RequestContext.HttpContext.Request; 
     if (request.IsAjaxRequest()) 
     { 
      if (!(request.IsAuthenticated && CanAccess)) 
      { 
       filterContext.Result = new AjaxAwareRedirectResult(redirectPage); 
       return; 
      } 
     } 

     base.OnAuthorization(filterContext); 
    } 
} 

public class AjaxAwareRedirectResult : RedirectResult 
{ 
    public AjaxAwareRedirectResult(string url) 
     : base(url) 
    { 
    } 

    public override void ExecuteResult(ControllerContext context) 
    { 
     if (context.RequestContext.HttpContext.Request.IsAjaxRequest()) 
     { 

      string destinationUrl = UrlHelper.GenerateContentUrl(Url, context.HttpContext); 

      JavaScriptResult result = new JavaScriptResult() 
      { 
       Script = "window.location='" + destinationUrl + "';" 
      }; 
      result.ExecuteResult(context); 
     } 
     else 
      base.ExecuteResult(context); 
    } 
} 

Ora è possibile consentire la modifica del contenuto dal proprietario o dall'amministratore. Sto chiamando questo Attributo come Ajax, perché gestirà anche AjaxRequest. Spero che questo aiuti.

saluti

Parinder

Answer 3

public class Entity 
{ 
    public Right[] Rights { get; set; }   
} 

public class Right 
{ 
    public User user {get;set;} 
    public Permission[] permissions {get;set;} 

} 

public class Foo : Entity 
{ 


} 

public class Bar : Entity 
{ 

} 

Nell'approccio superiore un'Entity classe base che immagazzinano i diritti un particolare utente contiene oltre tale entità. Eredita tutte le classi che si desidera proteggere dalla classe Entity.