Comment faire pour activer la SCRO en ASP.NET de Base

Je suis en train d'activer l'origine de la croix-partage des ressources sur mon ASP.NET Web de Base de l'API, mais je suis coincé.

La EnableCors attribut accepte policyName de type string comme paramètre:

//Summary:
//    Creates a new instance of the Microsoft.AspNetCore.Cors.Core.EnableCorsAttribute.
//
//Parameters:
//  policyName:
//    The name of the policy to be applied.
public EnableCorsAttribute(string policyName);

Ce qui ne l' policyName signifie et comment puis-je configurer de la SCRO sur un ASP.NET de Base de l'API Web?

voici l'article docs.microsoft.com/en-us/aspnet/core/security/cors

InformationsquelleAutor Oluwafemi | 2015-08-11

asp.net-core c#

221

Vous devez configurer un SCRO politique au démarrage de l'application dans le ConfigureServices méthode:
```
public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
    {
        builder.AllowAnyOrigin()
               .AllowAnyMethod()
               .AllowAnyHeader();
    }));

    //...
}
```
La CorsPolicyBuilder dans builder vous permet de configurer la stratégie de vos besoins. Vous pouvez maintenant utiliser ce nom pour appliquer la stratégie des contrôleurs et des actions:
```
[EnableCors("MyPolicy")]
```
Ou de l'appliquer à toutes les demandes:
```
public void Configure(IApplicationBuilder app)
{
    app.UseCors("MyPolicy");

    //...
}
```
- J'ai trouvé cette application.UseCors("Mastratégie") n'a pas fonctionné pour mon API points de terminaison. J'avais besoin explicitement [EnableCors("Mastratégie")] sur le contrôleur de points d'extrémité en question.
- Vous devez placer cette ligne avant tout des points de terminaison.
- À partir de l'officiel docs: "afin de permettre À la SCRO pour l'ensemble de votre application ajouter de la SCRO middleware pour votre demande de pipeline à l'aide de la UseCors méthode d'extension. Notez que la SCRO middleware doit précéder tout points de terminaison définis dans votre application que vous souhaitez prendre en charge les requêtes d'origine (ex. avant tout appel à UseMvc)."
- Je vais essayer cela, mais il ne fonctionne pas pour moi. Toutes les pensées? Voir aussi stackoverflow.com/questions/49900141/...
- J'ai ajouté de l'app.UseCors() après application.AddMvc() et ça ne fonctionne pas. Parce que l'ordre d'Utilisation des méthodes affecte la façon dont le middleware fonctionne!
- Owwww... Merci frère 🙂
- Quels sont les risques de permettre à n'importe quelle origine?
InformationsquelleAutor Henk Mollema
83

Si vous utilisez .Net-Core 1.1

Malheureusement, les docs sont très confus dans ce cas précis. Donc je vais faire très simple:
- Ajouter Microsoft.AspNetCore.Cors package nuget pour votre projet
- Dans ConfigureServices méthode, ajouter services.AddCors();
- Dans Configure méthode, avant d'appeler app.UseMvc() et app.UseStaticFiles(), ajouter:
```
app.UseCors(builder => builder
    .AllowAnyOrigin()
    .AllowAnyMethod()
    .AllowAnyHeader()
    .AllowCredentials());
```
Que c'est. Chaque client a accès à vos ASP.NET Base Site web/API.

Si vous utilisez .Net-Core 2.0
- Ajouter Microsoft.AspNetCore.Cors package nuget pour votre projet
- dans ConfigureServices méthode, avant d'appeler services.AddMvc(), ajouter:
```
 services.AddCors(options =>
    {
        options.AddPolicy("AllowAll",
            builder =>
            {
                builder
                .AllowAnyOrigin() 
                .AllowAnyMethod()
                .AllowAnyHeader()
                .AllowCredentials();
            });
    });
```
- (Important) Dans Configure méthode, avant appel app.UseMvc(), ajouter app.UseCors("AllowAll");
  
  AllowAll est le nom de la politique qui nous devons mentionner dans l'app.UserCors. Il pourrait être n'importe quel nom.
- vrai, la pensée que je peux activer l'un d'entre eux !
- Merci. J'ai eu mon AddCors après UseMvc et qui était à l'origine, il ne fonctionnera pas correctement. La vôtre est la seule réponse que le mentionne.
- Cela ne fonctionne pas, je ne pense pas. Lors de la fourniture des informations d'identification, vous ne pouvez pas permettre à n'importe quelle origine. Je suis encore à essayer d'obtenir que cela fonctionne.
- C'est la clé de la pièce: .UseCors() avant .UseMvc()
- Je vais essayer cela, mais il ne fonctionne pas pour moi. Toutes les pensées? Voir aussi stackoverflow.com/questions/49900141/...
- Le temps perdu ne sachant pas sur UseCors avant UserMvc... merci pour l'aide!
- J'ai perdu mon temps en le plaçant après application.UseMvc();
InformationsquelleAutor Vahid Amiri
32

Basé sur Henk de réponse j'ai été capable de trouver le nom de domaine spécifique, la méthode que je veux permettre à et aussi l'en-tête, je veux activer la SCRO pour:
```
public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options =>
         options.AddPolicy("AllowSpecific", p => p.WithOrigins("http://localhost:1233")
                                                   .WithMethods("GET")
                                                   .WithHeaders("name")));
    services.AddMvc();
}
```
utilisation:
```
[EnableCors("AllowSpecific")]
```
- Ce n'est pas de fournir une réponse à la question. À la critique ou à la demande de clarification d'un auteur, de laisser un commentaire en dessous de leur poste.
- To critique or request clarification from an author Je ne pense pas que ce soit le cas ici et Henk de réponse ont été déjà marquées. Ma réponse était un add-on si vous souhaitez permettre à des domaines spécifiques.
- Quelque chose manque dans votre code, 'IServiceCollection' ne contient pas une définition pour 'ConfigureCors'. S'il vous plaît vérifier et essayer de donner une réponse complète.
- Veuillez vérifier mes mises à jour de réponse. J'ai trouvé que ConfigureCors a été changé pour AddCors.
InformationsquelleAutor Oluwafemi

Vous devez configurer au Démarrage.cs de la classe

services.AddCors(options =>
        {
            options.AddPolicy("CorsPolicy",
                builder => builder.AllowAnyOrigin()
                .AllowAnyMethod()
                .AllowAnyHeader()
                .AllowCredentials());
        });

InformationsquelleAutor Sunil Dhappadhule

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy("AllowAnyOrigin",
                builder => builder
                .AllowAnyOrigin()
                .AllowAnyMethod()
                .AllowAnyHeader());
        });

        services.Configure<MvcOptions>(options => {
            options.Filters.Add(new CorsAuthorizationFilterFactory("AllowAnyOrigin"));
        });            
    }

Merveilleuse façon de contourner les déjà déployé la sécurité du navigateur. Il suffit de ne pas!
Je ne pense pas que ce sera voté. C'est une "autre" façon. Vous pouvez soit utiliser le "UseCors()" méthode ou bien ajouter un global MVC filtre comme ce que Nathan a fait ici.
cela fonctionne pour moi .net core 2.2 plus l'ajout d'application.UseCors("AllowAnyOrigin"); dans "Configurer" méthode

InformationsquelleAutor Nathan Alard

2

Si vous hébergez sur IIS, une des raisons possibles est que vous obtenez c'est parce que IIS est le blocage OPTIONS verbe. J'ai passé presque une heure à cause de cela:

Un révélateur indication est que vous obtenez 404 erreur lors de l' OPTIONS demande.

Pour corriger cela, vous devez indiquer explicitement IIS pas pour bloquer OPTIONS demande.

Allez à la Demande de Filtrage:

Assurez-vous que les OPTIONS sont autorisés:

Ou, il suffit de créer un web.config avec le paramètre suivant:
```
<system.webServer>
    <security>
        <requestFiltering>
            <verbs>
                <remove verb="OPTIONS" />
                <add verb="OPTIONS" allowed="true" />
            </verbs>
        </requestFiltering>
    </security>
</system.webServer>
```
- Merci..sa a fonctionné pour moi
InformationsquelleAutor Rosdi Kasim
2

Spécifiquement dotnet core 2.2 avec SignalR vous devez modifier

.WithOrigins("http://localhost:3000") ou

.SetIsOriginAllowed(isOriginAllowed: _ => true) //for all origins

au lieu .AllowAnyOrigin() avec .AllowCredentials()

https://trailheadtechnology.com/breaking-change-in-aspnetcore-2-2-for-signalr-and-cors/

https://github.com/aspnet/AspNetCore/issues/4483

InformationsquelleAutor PJ3

Vous devez vous connecter pour publier un commentaire.