Jeton d'Authentification Basée en ASP.NET de Base

Je travaille avec ASP.NET application de Base. Je suis en train de mettre en œuvre Jeton d'Authentification Basée sur les, mais ne peut pas comprendre comment utiliser les nouvelles Système De Sécurité pour mon cas.
Je suis passé par exemples mais ils ne m'aide pas beaucoup, ils sont soit en utilisant l'authentification par cookie ou l'authentification externe (GitHub, Microsoft, Twitter).

Ce que mon scénario est: angularjs application doit demander /token url passant nom d'utilisateur et mot de passe. WebApi devrait autoriser l'utilisateur et le retour access_token qui sera utilisé par angularjs application dans la suite de demandes.

J'ai trouvé un grand article à propos de la mise en œuvre exactement ce dont j'ai besoin dans la version actuelle de ASP.NET - Base de jetons d'Authentification à l'aide de ASP.NET Web API 2, Owin, et de l'Identité. Mais il n'est pas évident pour moi comment faire la même chose dans ASP.NET de Base.

Ma question est: comment faire pour configurer ASP.NET Core WebApi application avec base de jetons d'authentification?

InformationsquelleAutor Grant | 2015-03-14
  1. 124

    Mis à jour pour .Net Core 2:

    Les versions précédentes de cette réponse utilisé RSA; ce n'est vraiment pas nécessaire si votre même code qui génère les jetons est également la vérification de l'jetons. Toutefois, si vous distribuez des copies de la responsabilité, vous avez probablement encore envie de le faire à l'aide d'une instance de Microsoft.IdentityModel.Tokens.RsaSecurityKey.

    1. Créer quelques constantes que nous utiliserons plus tard; voici ce que j'ai fait:

      const string TokenAudience = "Myself";
const string TokenIssuer = "MyProject";

    2. Ajouter à votre Démarrage.cs ConfigureServices. Nous allons utiliser l'injection de dépendance plus tard pour accéder à ces paramètres. Je suis en supposant que votre authenticationConfiguration est un ConfigurationSection ou Configuration d'un objet, tel que vous pouvez avoir une autre config pour le débogage et la production. Assurez-vous de stocker votre clé en toute sécurité! Il peut être n'importe quelle chaîne.

      var keySecret = authenticationConfiguration["JwtSigningKey"];
var symmetricKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(keySecret));

services.AddTransient(_ => new JwtSignInHandler(symmetricKey));

services.AddAuthentication(options =>
{
    //This causes the default authentication scheme to be JWT.
    //Without this, the Authorization header is not checked and
    //you'll get no results. However, this also means that if
    //you're already using cookies in your app, they won't be 
    //checked by default.
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
})
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters.ValidateIssuerSigningKey = true;
        options.TokenValidationParameters.IssuerSigningKey = symmetricKey;
        options.TokenValidationParameters.ValidAudience = JwtSignInHandler.TokenAudience;
        options.TokenValidationParameters.ValidIssuer = JwtSignInHandler.TokenIssuer;
    });

      J'ai vu d'autres réponses changer d'autres paramètres, tels que ClockSkew; les valeurs par défaut sont configurés de telle sorte qu'il doit travailler pour les environnements distribués, dont les horloges ne sont pas exactement dans la synchronisation. Ce sont les seuls paramètres que vous avez besoin de changer.

    3. Mettre en place l'Authentification. Vous devriez avoir cette ligne avant tout le middleware qui nécessite votre User informations, telles que les app.UseMvc().

      app.UseAuthentication();

      Noter que ce ne sera pas la cause de votre jeton émis avec la SignInManager ou quoi que ce soit d'autre. Vous devrez fournir votre propre mécanisme de sortie de votre JWT - voir ci-dessous.

    4. Vous voulez spécifier une AuthorizationPolicy. Cela vous permettra de spécifier des contrôleurs et des actions qui ne permettent au Porteur de jetons d'authentification à l'aide de [Authorize("Bearer")].

      services.AddAuthorization(auth =>
{
    auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
        .AddAuthenticationTypes(JwtBearerDefaults.AuthenticationType)
        .RequireAuthenticatedUser().Build());
});

    5. Voici la partie la plus délicate: la construction du jeton.

      class JwtSignInHandler
{
    public const string TokenAudience = "Myself";
    public const string TokenIssuer = "MyProject";
    private readonly SymmetricSecurityKey key;

    public JwtSignInHandler(SymmetricSecurityKey symmetricKey)
    {
        this.key = symmetricKey;
    }

    public string BuildJwt(ClaimsPrincipal principal)
    {
        var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

        var token = new JwtSecurityToken(
            issuer: TokenIssuer,
            audience: TokenAudience,
            claims: principal.Claims,
            expires: DateTime.Now.AddMinutes(20),
            signingCredentials: creds
        );

        return new JwtSecurityTokenHandler().WriteToken(token);
    }
}

      Puis, dans votre contrôleur de l'endroit où vous voulez que votre jeton, quelque chose comme ce qui suit:

      [HttpPost]
public string AnonymousSignIn([FromServices] JwtSignInHandler tokenFactory)
{
    var principal = new System.Security.Claims.ClaimsPrincipal(new[]
    {
        new System.Security.Claims.ClaimsIdentity(new[]
        {
            new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.Name, "Demo User")
        })
    });
    return tokenFactory.BuildJwt(principal);
}

      Ici, je suis en supposant que vous avez déjà l'un des principaux. Si vous utilisez d'Identité, vous pouvez utiliser IUserClaimsPrincipalFactory<> pour transformer votre User dans un ClaimsPrincipal.

    6. Pour le tester: Obtenir un jeton, le mettre en forme à jwt.io. Les instructions que j'ai fournis ci-dessus vous permettent également d'utiliser le secret de votre config pour valider la signature!

    7. Si vous avez rendu ce dans une vue partielle sur votre page HTML en combinaison avec le porteur d'authentification uniquement dans .Net 4.5, vous pouvez maintenant utiliser un ViewComponent à faire de même. C'est essentiellement le même que l'Action du Contrôleur de code ci-dessus.

    • pouvez-vous fournir un échantillon supplémentaire de votre Api Contrôleur qui génère des Jetons? Mon OAuthBearerAuthenticationOptions ne sont pas résolus. Est le services.Configure<OAuthBearerAuthenticationOptions> appel de méthode assez pour vous inscrire avec le construit en DI? Merci
    • Vous devez en fait injecter IOptions<OAuthBearerAuthenticationOptions> pour utiliser les Options; l'utilisation d'un objet d'Options directement n'est pas pris en charge en raison de la configuration avec un nom qui est pris en charge par les Options de Modèle de cadre.
    • Je suis d'accord, la génération de la signature d'informations d'identification via la nouvelle ASP.NET 5 Protection des Données bloc serait l'idéal. J'ai eu une conversation avec Barry Dorrans (à partir de la ASP.NET de l'équipe) il y a quelques jours pour voir si je ne pouvais pas utiliser ses belles fonctionnalités de gestion de magasin de générer une clé RSA et l'utiliser comme la clé de signature pour le Réseau.De sécurité.OpenIdConnect.Serveur. Malheureusement, une fois qu'il est stocké, il n'y a aucun moyen d'exporter une clé et son matériel à l'aide de la nouvelle DP bloc. J'ai été dit à l'ASP.NET l'équipe n'avait pas l'intention de changer cela, de sorte que la création de votre propre certificat ou une clé RSA est probablement votre meilleur pari.
    • Je l'ai fait moi-même, mais espérais quelque chose de plus convivial de la ASP.NET de l'équipe. Je vais ajouter ça à ma réponse une fois que ma conversion à la bêta-5 fonctionne à nouveau!
    • Génial! Avez-vous prévu des mises à jour bientôt? 🙂
    • Mise à jour pour ce que je suis en utilisant, bien que maintenant la réponse doit obtenir une réécriture. Merci pour piquer moi!
    • Merci pour la rapidité de votre mise à jour! Dans le cas où vous pouvez partager la solution complète une fois que c'est prêt, vous pouvez répondre à ma question ici 🙂 stackoverflow.com/questions/30546542/...
    • Pour info, j'ai ouvert un ticket au aspnet/DataProtection: github.com/aspnet/DataProtection/issues/86. Se sentir libre pour upvote elle 😉
    • Qu'est-ce bearerOptions.SecurityTokenValidators liste? (C'est nul à l'intérieur de mon code. Suis-je la supervision de quelque chose?)
    • bearerOptions.SecurityTokenValidators = new List<ISecurityTokenValidator>(); bearerOptions.SecurityTokenValidators.Add(new JwtSecurityTokenHandler());
    • #5 a, depuis, été changé à la suite de Microsoft.AspNet.L'authentification.OAuthBearer bêta - 5 - 6 et peut-être plus tôt bêtas, mais n'ont pas confirmé ces. auth.AddPolicy("Porteur", de nouvelles AuthorizationPolicyBuilder () .AddAuthenticationSchemes(OAuthBearerAuthenticationDefaults.AuthenticationScheme).RequireAuthenticatedUser().Build());
    • Juste pour ma compréhension de cette (grande) à répondre à des listes de ce que vous avez besoin de changer de l' (aussi grand) article lié à l'OP?
    • La réponse doit pouvoir être utilisée de façon autonome, comme l'article est pour les versions précédentes de .Net; toutefois, l'article donne beaucoup d'informations de fond qui n'est pas inclus dans cette réponse, et peut-être utile de toute façon!
    • Merci @MattDeKrey! C'est de loin le meilleur post sur le sujet sur le web aujourd'hui. La partie que je ne suis pas la compréhension est la ClaimsIdentity. Comment un utilisateur peut passer en toute sécurité d'un nom d'utilisateur et mot de passe qui vous entraînera dans un jeton? Avez-vous également considéré comme IdentityServer (identityserver.github.io)?
    • Étape 6 détails de la construction du jeton; vous en aurez besoin pour authentifier l'utilisateur vous-même sur votre propre, cependant, de préférence, à l'aide de SSL.
    • Dans beta6: Mettre IOptions<OAuthBearerAuthenticationOptions> dans la construction comme l'injection vous oblige à faire un petit changement pour les parties de code: "var gestionnaire = bearerOptions.SecurityTokenValidators..." "devient var gestionnaire = bearerOptions.Des Options.SecurityTokenValidators..."
    • Combien de temps prend le jeton dernier et comment pouvons nous rafraîchir?
    • Je vous recommande de le faire le bearerOptions.Options dans le constructeur plutôt que de préserver une référence à l'ensemble de la IOptions<>, mais c'est le style. Le jeton comme dans l'exemple de n'expire pas, mais le handler.CreateToken prend des paramètres supplémentaires, soit après la date de jeton ou de définir une date d'expiration: ... DateTime? notBefore = default(DateTime?), DateTime? expires = default(DateTime?), ...
    • Merci pour la réponse. Je vais déplacer les options de l'objet, c'est une bonne idée. Quand le jeton arrive à expiration ou est sur ce que c'est, nous venons de générer un nouveau et passer s'ils ont besoin d'un nouveau? Aussi, comment peut-on révoquer un jeton émis si ils n'ont pas d'échéance? J'ai l'intention d'écrire un article sur comment j'ai mis en place votre solution, mais je veux être approfondie.
    • Tout comme dans l'article mentionné par les OP (Partie 3), vous aurez besoin de rafraîchir les jetons manuellement je ferais passer dans l'ancien jeton et obtenir un nouveau juste avant la date d'expiration. Vous ne pouvez pas terminer un jeton de lui-même si vous ne définissez pas de délai d'expiration; vous auriez besoin pour le gérer au sein de votre propre magasin de données si vous avez besoin de cette fonctionnalité.
    • L'article de l'OP mentionné utilise un OAuthValidateClientAuthenticationcontext et une sous-classe de OAuthAuthorizationServerProvider afin de gérer l'actualisation des jetons. Ces travaux avec votre approche, ou dois-je venir avec quelque chose d'autre?
    • Je crois que ces classes ont disparu; la génération d'un nouveau jeton doit être à l'aide du code à partir de l'Étape 6 de nouveau dans un prochain appel et d'obtenir le client à utiliser le nouveau jeton.
    • Merci, j'ai compris comment faire. Un autre problème que je vais avoir, c'est quand le jeton d'accès expire, je suis un SecurityTokenExpiredException: IDX10223: durée de Vie de la validation a échoué. Le jeton est expiré. Ce n'est pas bon, parce que j'ai besoin de revenir un 401 ou d'autres codes. Aucune idée de par où attraper cette et agir sur elle?
    • Je l'ai résolu en ajoutant ma ExceptionHandlerMiddleware emballage de la _next appeler comme ça try { attendent _next(contexte); } catch(SecurityTokenExpiredException stex) { _logger.LogDebug("Un jeton expiré a été fourni:" + stex.Message, stex); le contexte.Réponse.StatusCode = StatusCodes.Status401Unauthorized; le contexte.Réponse.Les en-têtes.Clear(); attendent contexte.Réponse.WriteAsync(JsonConvert.SerializeObject(new { Exception = stex.GetType().FullName, ErrorMessage = stex.Message })); }
    • Vous pouvez également utiliser OAuthBearerAuthenticationOptions.Les Notifications.AuthenticationFailed délégué
    • J'obtiens un "Système.InvalidOperationException: Pas de SecurityTokenValidator disponible pour les token: {JWT jeton que j'ai donnée au client}" exception lorsque je passe de l'Autorisation: Porteur {Token}". Est-il une solution?
    • J'ai remarqué que, aussi, avec la dernière version. Je n'ai pas eu la chance de trouver une solution pour le moment. Je vais revenir avec une autre mise à jour quand j'y arriverai!
    • J'ai utilisé cette réponse comme un point de départ pour un exemple simple de la base de jetons d'authentification, et mis à jour à travailler contre les beta 7 - voir github.com/mrsheepuk/ASPNETSelfCreatedTokenAuthExample - intègre également quelques-uns des pointeurs à partir de ces observations.
    • merci beaucoup pour cet exemple. J'ai été déchirant mes cheveux!! Très apprécié.
    • regarde grand - merci pour le mettre ensemble! Une chasse aux sorcières, quand on va beta8 est que vous avez besoin de remplacer OAuthBearer avec JwtBearer; je vais mettre à jour ma réponse une fois beta8 est entièrement libéré. (Bientôt!) @BurakTamurk - je ne suis plus l'obtention de cette exception; c'était peut-être une version spécifique du cadre?
    • Bon point, j'avais remarqué que quelque part lorsque vous essayez de trouver le code source pour OAuthBearer - j'ai ajouté des commentaires dans les lieux qu'il faudrait changer.
    • Merci beaucoup pour votre exemple @MarkHughes, j'en avais besoin pour assembler le tout et obtenir ce travail. Cependant, comme vous et MattDeKrey l'ont noté, il est tout à fait rompu dans beta8. J'ai réussi à mettre à niveau tout pour beta8 donc mon code permet de compiler et de servir les ordinateurs d'extrémité non authentifié, mais il semble que nous avons besoin de mettre en place Jwt différemment - toute aide à la configuration de Jwt pour beta8 sera très apprécié!
    • souhaitez-vous envisager d'inclure un lien vers MarkHughes' exemple, dans votre réponse? Je trouve votre réponse très utile, mais ne pouvait pas tout à fait la façon dont tout mis ensemble jusqu'à ce que j'ai trouvé son exemple, et il m'a fallu un bon moment pour remarquer ici-bas et au bas des commentaires! Merci beaucoup à vous deux en tout cas.
    • J'ai mis à jour mon projet GitHub et posté un travail beta8 exemple dans une réponse distincte - laissez-moi savoir si cela fonctionne pour vous.
    • de nouveau mis à Jour pour la RC1 - les anciennes versions de Beta7 et Beta8 disponible dans les branches sur GitHub.
    • Comment puis-je ajouter/retirer les clés et l'application est au courant de ces changements(sans avoir à redémarrer l'application)?
    • Si par touches vous dire jetons, JWT ne prend pas en charge la révocation de jetons. Si vous faites allusion à la Signature d'informations d'Identification, je suppose que vous auriez besoin de mise à jour et et de remplacer les options d'authentification - probablement pas une tâche facile. Bonne chance!
    • En raison de ma mauvaise compréhension du processus, je faisais allusion à la SigningCredentials mais ce que je voulais demander est réelle sur les jetons.
    • Oui, la nature de l'JWT jetons, c'est qu'ils sont de courte durée et ne peut être révoqué. C'est pourquoi le /Token action est si important - pour obtenir un nouveau jeton alors que l'utilisateur est toujours sur votre site!

    InformationsquelleAutor Matt DeKrey
  2. 80

    De travail de Matt Dekrey fabuleux répondre, j'ai créé un travail entièrement exemple de base de jeton d'authentification, de travail contre ASP.NET de Base (1.0.1). Vous trouverez le code complet dans ce repository sur GitHub (les branches alternatives pour 1.0.0-rc1, beta8, beta7), mais en bref, les étapes importantes sont:

    Générer une clé pour votre application

    Dans mon exemple, je vais générer une clé aléatoire à chaque fois que l'application démarre, vous aurez besoin pour générer et stocker dans un endroit et de les fournir à votre demande. Voir ce fichier, pour la façon dont je suis la génération d'une clé aléatoire et comment vous pouvez l'importer à partir d'un .fichier json. Comme suggéré dans les commentaires de @kspearrin, le API de Protection des données semble comme un candidat idéal pour la gestion des clés "correctement", mais je n'ai pas travaillé si c'est encore possible. Veuillez soumettre une demande d'extraction si vous en sortir!

    De démarrage.cs - ConfigureServices

    Ici, nous avons besoin de charger une clé privée pour nos jetons d'être signé, ce qui nous permettra également de l'utiliser pour vérifier les jetons qu'ils sont présentés. Nous sommes de stockage de la clé dans une classe de niveau variable key que nous allons ré-utiliser dans la configuration de la méthode ci-dessous. TokenAuthOptions est une simple classe qui détient la signature de l'identité, de l'audience et de l'émetteur dont nous aurons besoin dans la TokenController pour créer nos clés.

    //Replace this with some sort of loading from config /file.
RSAParameters keyParams = RSAKeyUtils.GetRandomKey();

//Create the key, and a set of token options to record signing credentials 
//using that key, along with the other parameters we will need in the 
//token controlller.
key = new RsaSecurityKey(keyParams);
tokenOptions = new TokenAuthOptions()
{
    Audience = TokenAudience,
    Issuer = TokenIssuer,
    SigningCredentials = new SigningCredentials(key, SecurityAlgorithms.Sha256Digest)
};

//Save the token options into an instance so they're accessible to the 
//controller.
services.AddSingleton<TokenAuthOptions>(tokenOptions);

//Enable the use of an [Authorize("Bearer")] attribute on methods and
//classes to protect.
services.AddAuthorization(auth =>
{
    auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
        .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme‌​)
        .RequireAuthenticatedUser().Build());
});

    Nous avons également mis en place une politique d'autorisation afin de nous permettre d'utiliser [Authorize("Bearer")] sur les systèmes d'extrémité et les classes que nous souhaitons protéger.

    De démarrage.cs - Configurer

    Ici, nous avons besoin de configurer le JwtBearerAuthentication:

    app.UseJwtBearerAuthentication(new JwtBearerOptions {
    TokenValidationParameters = new TokenValidationParameters {
        IssuerSigningKey = key,
        ValidAudience = tokenOptions.Audience,
        ValidIssuer = tokenOptions.Issuer,

        //When receiving a token, check that it is still valid.
        ValidateLifetime = true,

        //This defines the maximum allowable clock skew - i.e.
        //provides a tolerance on the token expiry time 
        //when validating the lifetime. As we're creating the tokens 
        //locally and validating them on the same machines which 
        //should have synchronised time, this can be set to zero. 
        //Where external tokens are used, some leeway here could be 
        //useful.
        ClockSkew = TimeSpan.FromMinutes(0)
    }
});

    TokenController

    Dans le jeton contrôleur, vous devez avoir une méthode pour générer des clés signées à l'aide de la touche qui a été chargé au Démarrage.cs. Nous avons enregistré un TokenAuthOptions exemple au Démarrage, donc nous avons besoin d'injecter que dans le constructeur de TokenController:

    [Route("api/[controller]")]
public class TokenController : Controller
{
    private readonly TokenAuthOptions tokenOptions;

    public TokenController(TokenAuthOptions tokenOptions)
    {
        this.tokenOptions = tokenOptions;
    }
...

    Alors vous aurez besoin pour générer le jeton dans votre gestionnaire pour la connexion d'extrémité, dans mon exemple je vais prendre un nom d'utilisateur et le mot de passe et de valider à l'aide d'une instruction if, mais la principale chose que vous devez faire est de créer ou charger une identité basée sur les revendications et de générer le jeton pour que:

    public class AuthRequest
{
public string username { get; set; }
public string password { get; set; }
}
///<summary>
///Request a new token for a given username/password pair.
///</summary>
///<param name="req"></param>
///<returns></returns>
[HttpPost]
public dynamic Post([FromBody] AuthRequest req)
{
//Obviously, at this point you need to validate the username and password against whatever system you wish.
if ((req.username == "TEST" && req.password == "TEST") || (req.username == "TEST2" && req.password == "TEST"))
{
DateTime? expires = DateTime.UtcNow.AddMinutes(2);
var token = GetToken(req.username, expires);
return new { authenticated = true, entityId = 1, token = token, tokenExpires = expires };
}
return new { authenticated = false };
}
private string GetToken(string user, DateTime? expires)
{
var handler = new JwtSecurityTokenHandler();
//Here, you should create or look up an identity for the user which is being authenticated.
//For now, just creating a simple generic identity.
ClaimsIdentity identity = new ClaimsIdentity(new GenericIdentity(user, "TokenAuth"), new[] { new Claim("EntityID", "1", ClaimValueTypes.Integer) });
var securityToken = handler.CreateToken(new Microsoft.IdentityModel.Tokens.SecurityTokenDescriptor() {
Issuer = tokenOptions.Issuer,
Audience = tokenOptions.Audience,
SigningCredentials = tokenOptions.SigningCredentials,
Subject = identity,
Expires = expires
});
return handler.WriteToken(securityToken);
}

    Et cela devrait suffire. Juste ajouter [Authorize("Bearer")] à toute méthode ou classe que vous souhaitez protéger, et vous devriez obtenir un message d'erreur si vous essayez d'y accéder sans jeton présent. Si vous voulez retourner un 401 au lieu d'une erreur 500, vous aurez besoin d'enregistrer une exception personnalisée gestionnaire comme je l'ai dans mon exemple ici.

    • C'est vraiment un excellent exemple, et inclus toutes les pièces manquantes j'avais besoin de m' @MattDeKrey l'exemple fonctionne, merci beaucoup! Notez que quelqu'un est toujours cibler beta7 au lieu de beta8 peut encore trouver ce exemple, dans le github histoire
    • Heureux, il a aidé @nickspoon - si vous avez des problèmes avec ça, laissez-moi savoir ou de la pop dans une pull request sur github et je vais mettre à jour!
    • Avez-vous d'utiliser vos propres générées manuellement la clé de signature? Est-il possible de simplement puiser dans les clés déjà créé et géré par la protection des données des bibliothèques? N'est-ce pas ainsi que le cookie d'authentification des jetons de travail?
    • Je soupçonne qu'il ya un moyen de le faire @kspearrin - si vous savez comment vous laissez-moi savoir et je vais l'ajouter dans! Je vais jeter un oeil demain pour voir si je peux travailler ça.
    • Jetez un oeil à la la Protection des Données docs. Je les ai trouvé très bien écrit et complet, donc je suis sûr que nous avons besoin est là. Ma conjecture est que le IKeyManager peut exposer ce qui est nécessaire.
    • Je ne peux pas obtenir le poste pour prendre la authrequest, c'est toujours null. Je suis l'appelant à l'application/x-www-form-urlencoded et le corps est le nom d'utilisateur=TEST&password=TEST. Je me demandais si il pourrait être un bug dans la version bêta 8.
    • Il fonctionne pour moi à l'aide de l'application/json codant pour le post, je n'ai pas utilisé form-urlencoded contre Beta8 moi-même, ne peut donc pas commenter sur ce point.
    • oui je l'ai eu à travailler comme json trop. J'ai remarqué, quand j'ai inspecté l'objet de la Requête, qu'il y avait des erreurs sur certaines propriétés, il est peut-être en raison d'être d'une version bêta. De toute façon, merci beaucoup pour cet exemple.
    • J'ai eu une bonne façon de jouer avec l'API de protection des données des trucs aujourd'hui et je ne pouvais pas le faire fonctionner - en doutez, il est possible en quelque sorte, mais n'ont pas le temps d'y regarder de plus loin, maintenant. Si vous le trouver comment le faire, de la pop dans une pull request sur github ou me donner un indice ici et je vais le mettre à jour. Vous avez raison, par la voie, ceux qui sont très bons docs!
    • Pas de problème. Merci pour avoir un coup d'oeil. Je vais vous laisser savoir si tout ce qui vient d'elle, mais comme toi, plus j'ai regardé le moins d'espoir que je suis devenu. Peut-être que si...
    • Désolé de ne pas avoir une bonne compréhension sur token génération, mais ici vous ai vu a partagé beaucoup de code pour générer un jeton, mais ma question est la base de jetons d'authentification est sécurisé sans HTTPS/SSL ?
    • C'est pas mieux ou pire que n'importe quel autre schéma d'authentification sans HTTPS / SSL @Thomas - alors, non, il n'est pas sûr du tout, mais ce n'est rien d'autre.
    • Génial, vous avez déjà une version RC1 jusqu'!
    • Donc, je suis en train d'expérimenter de générer le jeton dans une autre application, et en passant à mon api web de l'application. J'ai créé un fichier json pour le rsa les paramètres et les fit tous la même pour les deux applications, et il semble fonctionner. Est-il autre chose que je devrais faire/regarder dehors pour?
    • Non, ce devrait être bon @evan - en fait, vous devriez être en mesure d'omettre la clé privée côté des choses de la demande de consommation comme il devrait être en mesure de vérifier la signature en utilisant la clé publique - cela permettrait de minimiser la distribution de la clé privée afin d'améliorer la sécurité globale de certains.
    • Merci pour ceci, cependant je n'arrive pas à comprendre pourquoi quelque chose qui a travaillé à partir de la boîte de ASP.Net 4 de l'API Web maintenant nécessite un peu de configuration ASP.Net 5. Semble comme un pas en arrière.
    • Je pense qu'ils sont vraiment la promotion sociale "auth" pour ASP.NET 5, ce qui rend un sens, je suppose, mais il y a des applications qui n'est pas appropriée, donc je ne suis pas sûr que je suis d'accord avec leur direction @JMK
    • Salut, j'ai utilisé cette solution pour mettre en œuvre la base de Jeton d'authentification à mon application. Jusqu'à présent, il fonctionne bien, mais lorsque je me connecte de cette façon, je ne peux pas obtenir l'Id de l'Utilisateur courant (de l'Utilisateur.GetUserId()) parce que c'est nul. Il semble que quelque chose est pas encore configuré. Avez-vous une idée de comment le faire fonctionner? J'ai créé problème dans votre dépôt Github, mais personne n'a répondu jusqu'à présent github.com/mrsheepuk/ASPNETSelfCreatedTokenAuthExample/issues/...
    • est-il possible que je peux réutiliser le jeton pour ASP.NET MVC autorisation?
    • Je ne le crois pas, comme vous devez ajouter la coutume de l'autorisation d'en-tête de la requête HTTP, qui vous n'avez aucun moyen de le faire pour la demande initiale pour le serveur fait directement par le navigateur web. Vous pouvez combiner cela avec l'authentification par cookie, si, ce qui pourrait fonctionner pour MVC routes demandée directement par le navigateur, j'ai utilisé un mélange de biscuit+porteur de la stratégie de moi-même et je peux confirmer que cela fonctionne.
    • Cette solution fonctionne pour moi en RC1, mais pas dans la RC2. GetToken fonctionne, mais lorsque je tente de l'utiliser, je reçois toujours Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker: Warning: Authorization failed for the request at filter 'Microsoft.AspNetCore.Mvc.Authorization.AuthorizeFilter'. Microsoft.AspNetCore.Mvc.ChallengeResult: Information: Executing ChallengeResult with authentication schemes (Bearer). Microsoft.AspNetCore.Authentication.JwtBearer.JwtBearerMiddleware: Information: AuthenticationScheme: Bearer was challenged. Peut-être que certains on fait face à un tel problème lors de migrer dans RC2
    • J'ai besoin de mettre à jour cette réponse pour la RC2 - je n'ai pas mis à jour notre application qui l'utilise pour RC2 encore donc je ne suis pas sûr de ce qui est impliqué. Je vais mettre à jour une fois que j'ai travaillé sur la différence...
    • Hey @MarkHughes, avez-vous mis à jour la solution pour la RC2. Je l'ai téléchargé aujourd'hui et semble comme il ne fonctionne toujours pas pour la RC2.... 🙁
    • Mise à jour pour dotnet de base de la version 1.0.1, pour toute personne qui est intéressé.
    • Pouvez-vous svp me dire comment faire pour passer le jeton. Je suis à l'aide de l'homme post. J'ai généré le jeton avec Succès avec une clé aléatoire. Je suis à recevoir 401 à chaque demande.J'ai suivi stackoverflow.com/questions/24709944/... . Mais ce n'est pas de travail, j'ai passé la valeur mention
    • Comment pouvons-nous ajouter d'actualisation jeton dans ce??
    • C'est un grand sujet... Pour effectuez une actualisation jeton vous avez besoin de générer deux jetons, une longue durée de vie du jeton qui ne peut être utilisé pour demander des nouvelles de courte durée jetons (et ces demandes doivent être revérifiés à l'encontre de votre sous-jacente d'authentification boutique pour assurer à l'utilisateur qu'elles représentent, est toujours valable), puis le court terme jetons devraient être utilisés pour faire l'validation de l'utilisateur sur tous les autres points de terminaison.

    InformationsquelleAutor Mark Hughes
  3. 3

    Vous pouvez avoir un coup d'oeil à l'OpenId connect des exemples qui illustrent la façon de traiter avec différents mécanismes d'authentification, y compris JWT des Jetons:

    https://github.com/aspnet-contrib/AspNet.Security.OpenIdConnect.Samples

    Si vous regardez les Cordova Backend projet, la configuration de l'API est comme suit:

               //Create a new branch where the registered middleware will be executed only for non API calls.
app.UseWhen(context => !context.Request.Path.StartsWithSegments(new PathString("/api")), branch => {
//Insert a new cookies middleware in the pipeline to store
//the user identity returned by the external identity provider.
branch.UseCookieAuthentication(new CookieAuthenticationOptions {
AutomaticAuthenticate = true,
AutomaticChallenge = true,
AuthenticationScheme = "ServerCookie",
CookieName = CookieAuthenticationDefaults.CookiePrefix + "ServerCookie",
ExpireTimeSpan = TimeSpan.FromMinutes(5),
LoginPath = new PathString("/signin"),
LogoutPath = new PathString("/signout")
});
branch.UseGoogleAuthentication(new GoogleOptions {
ClientId = "560027070069-37ldt4kfuohhu3m495hk2j4pjp92d382.apps.googleusercontent.com",
ClientSecret = "n2Q-GEw9RQjzcRbU3qhfTj8f"
});
branch.UseTwitterAuthentication(new TwitterOptions {
ConsumerKey = "6XaCTaLbMqfj6ww3zvZ5g",
ConsumerSecret = "Il2eFzGIrYhz6BWjYhVXBPQSfZuS4xoHpSSyD9PI"
});
});

    La logique dans /Fournisseurs/AuthorizationProvider.cs et le RessourceController de ce projet sont aussi mérite un coup d'œil ;).

    Sinon, vous pouvez également utiliser le code suivant pour valider les jetons (il y a aussi un extrait de code pour le faire fonctionner avec signalR):

            //Add a new middleware validating access tokens.
app.UseOAuthValidation(options =>
{
//Automatic authentication must be enabled
//for SignalR to receive the access token.
options.AutomaticAuthenticate = true;
options.Events = new OAuthValidationEvents
{
//Note: for SignalR connections, the default Authorization header does not work,
//because the WebSockets JS API doesn't allow setting custom parameters.
//To work around this limitation, the access token is retrieved from the query string.
OnRetrieveToken = context =>
{
//Note: when the token is missing from the query string,
//context.Token is null and the JWT bearer middleware will
//automatically try to retrieve it from the Authorization header.
context.Token = context.Request.Query["access_token"];
return Task.FromResult(0);
}
};
});

    Pour l'émission de jeton, vous pouvez utiliser le openId Connect server paquets comme suit:

            //Add a new middleware issuing access tokens.
app.UseOpenIdConnectServer(options =>
{
options.Provider = new AuthenticationProvider();
//Enable the authorization, logout, token and userinfo endpoints.
//options.AuthorizationEndpointPath = "/connect/authorize";
//options.LogoutEndpointPath = "/connect/logout";
options.TokenEndpointPath = "/connect/token";
//options.UserinfoEndpointPath = "/connect/userinfo";
//Note: if you don't explicitly register a signing key, one is automatically generated and
//persisted on the disk. If the key cannot be persisted, an exception is thrown.
//
//On production, using a X.509 certificate stored in the machine store is recommended.
//You can generate a self-signed certificate using Pluralsight's self-cert utility:
//https://s3.amazonaws.com/pluralsight-free/keith-brown/samples/SelfCert.zip
//
//options.SigningCredentials.AddCertificate("7D2A741FE34CC2C7369237A5F2078988E17A6A75");
//
//Alternatively, you can also store the certificate as an embedded .pfx resource
//directly in this assembly or in a file published alongside this project:
//
//options.SigningCredentials.AddCertificate(
//    assembly: typeof(Startup).GetTypeInfo().Assembly,
//    resource: "Nancy.Server.Certificate.pfx",
//    password: "Owin.Security.OpenIdConnect.Server");
//Note: see AuthorizationController.cs for more
//information concerning ApplicationCanDisplayErrors.
options.ApplicationCanDisplayErrors = true //in dev only ...;
options.AllowInsecureHttp = true //in dev only...;
});

    EDIT: j'ai mis en place une page unique application avec un jeton d'authentification basée sur la mise en œuvre à l'aide de l'Aurelia, avant la fin de cadre et ASP.NET de base. Il est également un signal R des connexions persistantes. Cependant je n'ai pas fait toute DB de mise en œuvre.
    Le Code peut être vu ici:
    https://github.com/alexandre-spieser/AureliaAspNetCoreAuth

    Espère que cette aide,

    Mieux,

    Alex

    InformationsquelleAutor Darxtar
  4. 1

    Ont un coup d'oeil à OpenIddict - c'est un nouveau projet (au moment de l'écriture) qui le rend facile à configurer la création de JWT des jetons et de l'actualisation des jetons dans les ASP.NET 5. La validation des jetons sont gérées par d'autres logiciels.

    En supposant que vous utilisez Identity avec Entity Framework, la dernière ligne est ce que vous souhaitez ajouter à votre ConfigureServices méthode:

    services.AddIdentity<ApplicationUser, ApplicationRole>()
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders()
.AddOpenIddictCore<Application>(config => config.UseEntityFramework());

    Dans Configure, vous avez défini OpenIddict pour servir JWT des jetons:

    app.UseOpenIddictCore(builder =>
{
//tell openiddict you're wanting to use jwt tokens
builder.Options.UseJwtTokens();
//NOTE: for dev consumption only! for live, this is not encouraged!
builder.Options.AllowInsecureHttp = true;
builder.Options.ApplicationCanDisplayErrors = true;
});

    Vous également configurer la validation de jetons dans Configure:

    //use jwt bearer authentication
app.UseJwtBearerAuthentication(options =>
{
options.AutomaticAuthenticate = true;
options.AutomaticChallenge = true;
options.RequireHttpsMetadata = false;
options.Audience = "http://localhost:58292/";
options.Authority = "http://localhost:58292/";
});

    Il y a un ou deux autres choses mineures, telles que votre DbContext doit dériver de OpenIddictContext.

    Vous pouvez voir une pleine longueur explication sur ce blog: http://capesean.co.za/blog/asp-net-5-jwt-tokens/

    Un fonctionnement de démonstration est disponible à: https://github.com/capesean/openiddict-test

    InformationsquelleAutor Sean