42 messaggi dal 12 agosto 2009
Sto realizzando un controller webapi dotnetconre, con runtime 4.5.2, che deve restituire stato 401 se non è presente una chiave in sessione.
La variabile in sessione viene inizializzata da una action mvc che restituice l vista della pagina iniziale. I servizi web api chiamati poi, restituiscono err 401 se la variabile non è presente.
Ma il session.id nel controller webApi è diverso da quello nel filtro.
Il controller mvc della pagine entry point invece ha il giust id.

La il metodo che setta la viariabile è questo. Essendo dacorato con AllowAnonymous, non viene effettuato il controllo dal filtro.
    [AllowAnonymous]
    public IActionResult Index()
    {
    
    HttpContext.Session.SetString("Foo", "Bar");
    HttpContext.Session.SetInt32("UserId", 1);
    return View();
    }


Qui il filtro
    public class SessionRequiredFilter : AuthorizeFilter
    {            
           
            
        /*...*/
        /// <summary>
        /// Performs the authorization check over teh Session. 
        /// </summary>
        /// <param name="context">The AuthorizationFilterContext.</param>
        /// <returns>A System.Threading.Tasks.Task that on completion indicates the filter has executed. </returns>
        /// <remarks>Performs checks only if the relative class or methods are not marked wirh a AllowAnonymous attribute, carrying an IAllowAnonymousFilter.</remarks>
        public override Task OnAuthorizationAsync(AuthorizationFilterContext context)
        {
            try
            {
                // If there is an IAllowAnonymousFilter filter, do nothing
                if (context.Filters.Any(filter => filter is IAllowAnonymousFilter))
                {
                    return base.OnAuthorizationAsync(context);
                }
    
                switch (this.validatorType)
                {
                    case ValidatorType.None:
                        {
                            //Just Checking the presence of any data by the Session Key
                            byte[] data;
                            if (!context.HttpContext.Session.TryGetValue(this.sessionKey, out data))
                            {
                                this.UnauthorizeContext(context);
                            }
                            break;
                        }
                    case ValidatorType.String:
                        {
                            //Checking the value of the string data from the Session Key invoking the provided validator
                            string data = context.HttpContext.Session.GetString(this.sessionKey);
                            if (data == null)
                            {
                                this.UnauthorizeContext(context);
                            }
                            else if (!this.sessionStringValueValidator.Invoke(data))
                            {
                                this.UnauthorizeContext(context, String.Join(String.Empty, new String[] { "Unexpected value in ", this.sessionKey, ": ", data }));
                            }
                        }
                        break;
                    
    
            }
            catch (Exception e)
            {
                context.HttpContext.Response.StatusCode = 500;
                context.Result = new AuthorizeFilterResult(e.Message);
            }
    
            return base.OnAuthorizationAsync(context);
        }
            
    }


In Starrtup.cs metoodo ConfigureServices e COnfigure:

    public void ConfigureServices(IServiceCollection services)
        {
            // Add framework services.
            services.AddMvc(
                options =>
                {
                    options.Filters.Add(new         Core.Auth.SessionRequiredFilter(Configuration["Security:Keyword"]));
                }
                );
            services.AddCors();
            services.AddDistributedSqlServerCache(options =>
            {
                options.ConnectionString = Configuration["Data:SessionConnection:ConnectionString"];
                options.SchemaName = "dbo";
                options.TableName = Configuration["Data:SessionConnection:TableName"];
                options.ExpiredItemsDeletionInterval = new TimeSpan(0, 5, 0);
            });
            services.AddSession(
                options =>
                {
                    //options.CookieHttpOnly = true;
                    options.CookieName = ".ASPNetCoreSession";
                    options.IdleTimeout = TimeSpan.FromMinutes(60);
                    options.CookiePath = "/";
                }
                );


            // Added - uses IOptions<T> for your settings.
            //services.AddOptions();
            
            services.Configure<Core.Configuration.ServerConfigurations>(Configuration.GetSection("ServerConfigurations"));


        }

    //And: Configure
    
      

    loggerFactory.AddConsole(Configuration.GetSection("Logging"));
    loggerFactory.AddDebug();
    
    //app.UseStaticFiles();
    app.UseSession();


Modificato da eomer1975 il 10 aprile 2017 10.09 -
registra il filtro a livello globale, come middleware, anziché come normale filtro. in questo modo riuscirai più facilmente ad applicarlo ad ogni richiesta. secondo me, infatti, il filtro AllowAnonymous in qualche modo interviene prima.

inoltre, spiega meglio cosa vuoi fare, magari c'è una via più semplice di questa. il tuo obiettivo è proteggere tutta l'applicazione, a parte alcune aree?

Daniele Bochicchio | ASPItalia.com
I libri su Windows, HTML5, ASP.NET, VS, Entity Framework
Chief Digital Officer@icubed
Microsoft Regional Director for Italy
42 messaggi dal 12 agosto 2009
Grazie daniele.
Adesso il problema era che le richieste ajax non trasmettevano anche il cookie, e quindi la sessione veniva ricreate, ma seguirò il tuo conosiglio comunque per migliorare l'architettura e le mie conoscenze sul "nuovo" framework.

L'obbiettivo è proteggere tutti i servizi, che possono essere consumati solo se all'accesso dell'app tramite il cintroller Home è andata a buon fine una procedura di autenticazione gestita da un'altra app trmite la quale si accede.
Modificato da eomer1975 il 12 aprile 2017 08.58 -
in ASP.NET Core la parte di autenticazione e autorizzazione è molto più raffinata. ti consiglio di dare un'occhiata a questo ;)

https://docs.microsoft.com/en-us/aspnet/core/security/authentication/

Daniele Bochicchio | ASPItalia.com
I libri su Windows, HTML5, ASP.NET, VS, Entity Framework
Chief Digital Officer@icubed
Microsoft Regional Director for Italy

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.