Hoe maak je CORS-authenticatie in WebAPI 2?

Het scenario is eenvoudig, ik moet inloggen vanaf een andere server (anders dan de API-server) om het toegangstoken op te halen.

Ik heb het pakket Microsoft.Owin.Corsgeïnstalleerd op de API-server. In het bestand Startup.Auth.cs, onder public void ConfigureAuth(IAppBuilder app), heb ik toegevoegd in

app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);

In WebApiConfig.cs, onder public static void Register(HttpConfiguration config), heb ik deze regels toegevoegd:

// Cors
var cors = new EnableCorsAttribute("*", "*", "GET, POST, OPTIONS");
config.EnableCors(cors);

Wat moet ik nog meer veranderen?

Antwoord 1, autoriteit 100%

Kijk naar wat ik heb gevonden!

Voeg enkele aangepaste headers toe in <system.webServer>.

<httpProtocol>
  <customHeaders>
    <add name="Access-Control-Allow-Origin" value="*" />
    <add name="Access-Control-Allow-Methods" value="GET, POST, OPTIONS, PUT, DELETE" />
  </customHeaders>
</httpProtocol>

Dan kan ik de CORS-authenticatie uitvoeren.

Antwoord 2, autoriteit 66%

Ik heb veel vallen en opstaan ​​gehad om het in te stellen voor een op AngularJS gebaseerde webclient.
Voor mij werken onderstaande benaderingen met ASP.NET WebApi 2.2 en op OAuth gebaseerde service.

1. Installeer Microsoft.AspNet.WebApi.Corsnuget-pakket.
2. Installeer Microsoft.Owin.Corsnuget-pakket.
3. Voeg config.EnableCors(new EnableCorsAttribute("*", "*", "GET, POST, OPTIONS, PUT, DELETE"));aan het bovenstaande van WebApiConfig.Register(config);regel in het bestand Startup.cs.
4. Voeg app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);toe aan het bestand Startup.Auth.cs. Dit moet worden gedaan voordat IAppBuilder.UseWebApi

wordt aangeroepen

5. Verwijder alle xml-instellingen wat Blaise deed.

Ik vond hier veel variaties en combinaties van setups op stackoverflow of blogartikelen. Dus de benadering van Blaise kan al dan niet verkeerd zijn. Het zijn gewoon andere instellingen denk ik.

Antwoord 3, autoriteit 42%

Na vele uren zoeken en kijken naar veel verschillende oplossingen hiervoor ben ik erin geslaagd om dit werkend te krijgen zoals hieronder beschreven.

Er zijn een aantal redenen waarom dit gebeurt. Waarschijnlijk heb je CORS op de verkeerde plaats ingeschakeld of is het twee keer of helemaal niet ingeschakeld.

Als u Web API en Owin Token-eindpunt gebruikt, moet u alle verwijzingen naar CORS in uw Web API-methode verwijderen en de juiste owin-methode toevoegen omdat web-api cors niet werken met Token-eindpunt terwijl Owin cors wel werkt voor zowel Web API als Token auth-eindpunten, dus laten we beginnen:

1. Zorg ervoor dat het Owin Cors-pakket is geïnstalleerd Verwijder elke regel
   dat je bijv.config.EnableCors(); van uw WebAPIconfig.cs-bestand

2. Ga naar je startup.cs-bestand en zorg ervoor dat je Owin Cors uitvoert
   voordat een van de andere configuraties wordt uitgevoerd.

   app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
   ConfigureAuth(app);

3. Als je nog steeds problemen hebt, ga dan naar: Startup.Auth.cs en zorg ervoor dat je het volgende in je ConfigureAuth-methode hebt staan ​​(je zou dit niet nodig moeten hebben als je startup.cs-bestand correct is)

app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);

Antwoord 4, autoriteit 28%

web.config

<appSettings>
  <add key="cors:Origins" value="*" />
  <add key="cors:Headers" value="*" />
  <add key="cors:Methods" value="GET, POST, OPTIONS, PUT, DELETE" />
</appSettings>

Startup.cs

var appSettings = WebConfigurationManager.AppSettings;
// If CORS settings are present in Web.config
if (!string.IsNullOrWhiteSpace(appSettings["cors:Origins"]))
{
    // Load CORS settings from Web.config
    var corsPolicy = new EnableCorsAttribute(
        appSettings["cors:Origins"],
        appSettings["cors:Headers"],
        appSettings["cors:Methods"]);
    // Enable CORS for ASP.NET Identity
    app.UseCors(new CorsOptions
    {
        PolicyProvider = new CorsPolicyProvider
        {
            PolicyResolver = request =>
                request.Path.Value == "/token" ?
                corsPolicy.GetCorsPolicyAsync(null, CancellationToken.None) :
                Task.FromResult<CorsPolicy>(null)
        }
    });
    // Enable CORS for Web API
    config.EnableCors(corsPolicy);
}

Opmerking: app.UserCors(...)moet worden aangeroepen voordat ASP.NET Identity wordt geconfigureerd.

Bron: ASP.NET Web Application Starter Kit(ASP.NET Web API, Identity, SignalR)

Antwoord 5, autoriteit 20%

Om het antwoord van Youngjae verder uit te werken, is er een geweldige tutorial over het instellen van OWIN met Web API en het inschakelen van CORS op http://bitoftech.net/2014/06/01/token-based-authentication-asp- net-web-api-2-owin-asp-net-identity/

U wilt het NuGet-pakket voor CORS toevoegen met het commando:
Install-Package Microsoft.Owin.Cors -Version 2.1.0

Voeg vervolgens toe
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);

naar uw configuratiemethode in Startup.cs, zodat het er ongeveer zo uitziet:

public void Configuration(IAppBuilder app)
{
    HttpConfiguration config = new HttpConfiguration();
    ConfigureOAuth(app);
    WebApiConfig.Register(config);
    app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
    app.UseWebApi(config);
}

Antwoord 6, autoriteit 11%

Het antwoord voor mij is gevonden op

Web Api 2 Preflight CORS-verzoek voor Bearer Token

Met name de /Token-aanvraag met een implementatie van OAuthAuthorizationServerProvider.GrantResourceOwnerCredentials voegde de header opnieuw toe. Voeg de OWIN CORS-dingen toe vóór elke andere OWIN-configuratie en verwijder de header van GrantResourceOwnerCredentials, volgens die link, en voila.
Veel succes.

Antwoord 7, autoriteit 11%

Ik wil alleen mijn ervaring delen. Ik heb de helft van de dag met mijn hoofd gestoten en geprobeerd het te laten werken. Ik las talloze artikelen en SO-vragen en uiteindelijk kwam ik erachter wat er mis was.

De regel

app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);

was niet de eerste in de Startupclass Configurationmethode. Toen ik het naar de top verplaatste, begon alles op magische wijze te werken.

En er waren geen aangepaste headers in web.configof config.EnableCors(corsPolicy);of iets anders nodig.

Ik hoop dat dit iemand zal helpen om wat tijd te besparen.

Antwoord 8, autoriteit 5%

Hier vindt u de verschillende manieren waarop u CORS op verschillende gebieden kunt inschakelen: http://www.asp.net/web-api/overview/security/enabling-cross-origin-requests-in-web-api

Hoe dan ook, ik had hetzelfde probleem, en door de koppen op verschillende manieren toe te voegen, kreeg ik niet de volledige oplossing.

Ik ontdekte dat de IIS handlers gebruikt die de configuratie van uw CORS-webapp overschrijven als u het tegenovergestelde niet opgeeft.

In mijn geval moest ik ook het gebruik van IIS-handlers verwijderen door de volgende configuratie toe te voegen aan de hoofdweb.config van mijn toepassing:

<system.webServer>
    <handlers>
      <remove name="ExtensionlessUrlHandler-Integrated-4.0" />
      <remove name="OPTIONSVerbHandler" />
      <remove name="TRACEVerbHandler" />
      <add name="ExtensionlessUrlHandler-Integrated-4.0" path="*." verb="*" type="System.Web.Handlers.TransferRequestHandler" preCondition="integratedMode,runtimeVersionv4.0" />
    </handlers>
</system.webServer>

Houd er rekening mee dat deze configuratie standaard kan worden ingesteld wanneer u een nieuw project maakt, afhankelijk van het type ervan, maar als u helemaal opnieuw begint, moet u deze configuratie waarschijnlijk toevoegen.

Antwoord 9, autoriteit 3%

Het toevoegen van klantheaders geeft u mogelijk niet zoveel vrijheid bij het aanpassen van uw beveiligingsbehoeften. Het opent alle andere delen van de api voor de wereld. De volgende code doet dat alleen voor “token”, en een ander deel van de api moet worden gedaan via EableCors-annotatie.

public void ConfigureAuth(IAppBuilder app)
{
    //other stuff
    app.Use(async (context, next) =>
    {
        IOwinRequest req = context.Request;
        IOwinResponse res = context.Response;
        if (req.Path.StartsWithSegments(new PathString("/Token")))
        {
            var origin = req.Headers.Get("Origin");
            if (!string.IsNullOrEmpty(origin))
            {
                res.Headers.Set("Access-Control-Allow-Origin", origin);
            }
            if (req.Method == "OPTIONS")
            {
                res.StatusCode = 200;
                res.Headers.AppendCommaSeparatedValues("Access-Control-    Allow-Methods", "GET", "POST");
                res.Headers.AppendCommaSeparatedValues("Access-Control-    Allow-Headers", "authorization", "content-type");
                return;
            }
        }
        await next();
    });
    //other stuff
}

Volg de instructie hierom Cors in te schakelen.

Antwoord 10

Als we OWIN-middleware gebruiken om CORS af te handelen, hoeven we geen headers toe te voegen aan de WebAPIConfig of het web.config-bestand. Ja, het toevoegen van de headers aan het web.config-bestand werkt wel als je openbare toegang wilt, maar als je de toegang moet beperken op basis van een witte lijst (domeinen), dan is het niet langer nodig om Alletoegang te geven je zou willen doen.

Met OWINS kunnen we dit aan door deze handler te implementeren:

OAuthAuthorizationServerProvider.MatchEndpoint

Met deze handler kunnen we de aanvraagmethode (OPTIONS, POST…) detecteren en of de aanvraag moet worden behandeld als een Authorize- of Token-eindpunt. Dit is het gebied waar logica kan worden toegevoegd om de Origin-header (verzoek) te controleren en te valideren of dit domein moet worden toegestaan ​​door de responsheader Access-Control-Allow-Origin toe te voegen.

string origin = context.Request.Headers.Get("Origin");
var found = IsDomainAllowed(origin);
 if (found){
      context.Response.Headers.Add("Access-Control-Allow-Origin",
                             new string[] { origin });
 }      

Kijk voor meer achtergrond hierover op deze link: http://www.ozkary.com/2016/04/web-api-owin-cors-handling-no-access.html