217 messaggi dal 08 marzo 2012
Ciao a Tutti,

ho un'applicazione web in Asp.NET Core che mette a disposizione un set di servizi.
I servizi per autenticarsi accetto un token ma vorrei inserire anche un blocco del dominio chiamante.

Ovvero accettare le chiamate solo il chiamante arriva da uno specifico dominio internet, altrimenti rifiutare.

Su Asp.NET (.NET Framework) accedevo alle servervariables ma su .NET Core ho difficoltà a recuperare la medesima informazione.

Sapreste indicarmi come fare?

Grazie!
329 messaggi dal 13 novembre 2009
https://docs.microsoft.com/it-it/aspnet/core/security/cors?view=aspnetcore-3.1

Oppure anche un sistema di throttling
217 messaggi dal 08 marzo 2012
Ciao,

grazie della risposta.
Non è tanto un problema di CORS.

Forse mi sono spiegato male. A livello programmatico devo poter verificare il dominio del chiamante e con una logica interna, legata ad un set di configurazioni, stabilire se quel dominio può o meno chiamare quel servizio.

Il controllo devo però farlo con delle regole dinamiche configurate nel database e non statisticamente come con le "Cors decoration".

È possibile?

Grazie
329 messaggi dal 13 novembre 2009
Alcune librerie di throttling stabiliscono regole su ip ecc. Direi che per semplificare le cose potresti nel middleware creare un servizio che intercetta la chiamata e quindi HttpRequest.Host e facendo la retrieve dal DB verificare il dominio censito o meno. La cosa potresti a quel punto parametrizzarla decorando controllers e actions.
Spero sia stato chiaro, qualcosa del genere lo fatto senza grossi sforzi su aspnet core, trovi qualcosa anche su aspitalia. Il concetto da seguire è quello di verificare i claims con un custom service
667 messaggi dal 13 novembre 2008
Contributi
ciao,
è possibile farlo in tanti modi, ma bisognerebbere sapere qual'è l'architettura, Cors comunque ci incastra...
alcuni esempi:
se parliamo di Azure puoi impostare regole direttamente a portale,
se hai modo di agire sulla procedura di rilascio del token, puoi fare li la verifica,
altrimenti puoi implementare un servizio custom che deriva da ICorsPolicyProvider, ad es. del tipo

.cs

    public class CorsPolicyAccessor : ICorsPolicyProvider
    {
        private readonly CorsOptions _options;
        public CorsPolicyAccessor(IOptions<CorsOptions> options)
        {
            if (options == null){throw new ArgumentNullException(nameof(options));}

            _options = options.Value;
        }
        public Task<CorsPolicy> GetPolicyAsync(HttpContext context, string policyName)
        {
            //verifica di non averlo già in CorsPolicy

            CorsPolicy cp = _options.GetPolicy(policyName);
            var origin = context.Request.Headers["Origin"].ToString();
            string result = cp.Origins.FirstOrDefault(x => x == origin);
           if (result == null)
            {
                if (...) //verifica dominio e se valido lo inserisce in CorsPolicy
                {
                    cp.Origins.Add(origin);
                }
            }
            cp.SupportsCredentials = true;
            return Task.FromResult(cp);
        }
    } 


a questo punto in Startup aggiungi il servizio come transient al servizio Cors, definendo una (o più) policy

            services.AddCors(o =>
            {
                o.AddPolicy("AllowXYZ", builder =>
                {
                    builder.AllowMethod(...)...;
                });

            }).AddTransient<ICorsPolicyProvider, CorsPolicyAccessor>();


che utilizzerai come attributo nelle api

    [EnableCors("AllowXYZ")]
    [Route("api/[controller]")]
    public class ... {}


Modificato da teo prome il 27 marzo 2020 10:10 -
1 messaggio dal 28 marzo 2020
Host rappresenta il dominio di destinazione non quello del chiamante (cfr. https://tools.ietf.org/html/rfc2616#section-14.36).

Quello che chiede non e' banale

Passo 1
Recuperare l'IP del client originale, non quello del chiamante che potrebbe essere qualche genere di reverse proxy come Azure Application Gateway. Per questo non ci sono standard precisi, ma in pratica basta controllare se c'e' un header X-Forwarded-For (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For). Se non c'e' un proxy, allora basta usare RemoteIpAddress https://docs.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.http.features.ihttpconnectionfeature.remoteipaddress.

Passo 2
A questo punto e' necessario convertire indirizzo IP nel dominio. Per questo puoi usare https://docs.microsoft.com/en-us/dotnet/api/system.net.dns.gethostentry?view=netcore-3.1 ma, attenzione, non e' un processo univoco. Ci possono essere molti domini associati allo stesso IP.
329 messaggi dal 13 novembre 2009
Appunto Host per a capire se la chiamata arriva dal proprio dominio e non da altrove. Detto questo qui si tratta anche di stabilire ci fa che cosa e come. Il codice precedente per definire nel middleware una policy è la giusta direzione da implementare con il chiamante database che definisce regole dinamiche ecc.
Ad esempio in azienda abbiamo utilizzato proprio questo sistema per controllare gli accessi realtime su webservice throttling ruoli abilitazione in tempo reale a vari livelli ecc
In un token tramite claims ecc è possibile fare più cose

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.