.NET कोर 2.0 पर JWT

Question 1

मैं JWT को डॉटनेट कोर 2.0 (अब अंतिम रिलीज पर पहुंचता हूं) पर काम करने के लिए काफी रोमांच में हूं। प्रलेखन का एक टन है, लेकिन सभी नमूना कोड अपग्रेड किए गए एपीआई का उपयोग करते हैं और कोर में नए सिरे से आते हैं, यह सकारात्मक रूप से चक्कर लगा रहा है कि यह कैसे लागू किया जाना चाहिए। मैंने जोस, लेकिन ऐप का उपयोग करने की कोशिश की। UseJwtBearerAuthentication को हटा दिया गया है, और आगे क्या करना है, इस पर कोई दस्तावेज नहीं है।

क्या किसी के पास एक ओपन सोर्स प्रोजेक्ट है जो डॉटनेट कोर 2.0 का उपयोग करता है जो केवल प्राधिकरण हेडर से एक जेडब्ल्यूटी को पार्स कर सकता है और मुझे एचएस 256 एनकोडेड जेडब्ल्यूटी टोकन के लिए अनुरोधों को अधिकृत करने की अनुमति देता है?

नीचे दिए गए वर्ग में कोई अपवाद नहीं है, लेकिन कोई अनुरोध अधिकृत नहीं है, और मुझे कोई संकेत नहीं मिलता है कि वे अनधिकृत क्यों हैं। प्रतिक्रियाएं 401 के खाली हैं, इसलिए मेरे लिए यह इंगित करता है कि कोई अपवाद नहीं था, लेकिन यह रहस्य मेल नहीं खा रहा है।

एक अजीब बात यह है कि मेरे टोकन HS256 एल्गोरिथ्म के साथ एन्क्रिप्ट किए गए हैं, लेकिन मुझे यह बताने के लिए कोई संकेतक नहीं है कि वह इसे उस एल्गोरिदम का उपयोग करने के लिए कहीं भी मजबूर करने के लिए कहे।

यहाँ कक्षा मैं अब तक है:

using System;
using System.Collections.Generic;
using System.IO;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Net.Http.Headers;
using Newtonsoft.Json.Linq;
using Microsoft.IdentityModel.Tokens;
using System.Text;

namespace Site.Authorization
{
    public static class SiteAuthorizationExtensions
    {
        public static IServiceCollection AddSiteAuthorization(this IServiceCollection services)
        {
            var signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes("SECRET_KEY"));

            var tokenValidationParameters = new TokenValidationParameters
            {
                // The signing key must match!
                ValidateIssuerSigningKey = true,
                ValidateAudience = false,
                ValidateIssuer = false,
                IssuerSigningKeys = new List<SecurityKey>{ signingKey },


                // Validate the token expiry
                ValidateLifetime = true,
            };

            services.AddAuthentication(options =>
            {
                options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;


            })

            .AddJwtBearer(o =>
            {
                o.IncludeErrorDetails = true;
                o.TokenValidationParameters  = tokenValidationParameters;
                o.Events = new JwtBearerEvents()
                {
                    OnAuthenticationFailed = c =>
                    {
                        c.NoResult();

                        c.Response.StatusCode = 401;
                        c.Response.ContentType = "text/plain";

                        return c.Response.WriteAsync(c.Exception.ToString());
                    }

                };
            });

            return services;
        }
    }
}

Question 2

यहां एक नियंत्रक के साथ पूर्ण काम करने वाला न्यूनतम नमूना है। मुझे आशा है कि आप पोस्टमैन या जावास्क्रिप्ट कॉल का उपयोग करके इसे देख सकते हैं।

appsettings.json, appsettings.Development.json। एक अनुभाग जोड़ें। नोट, कुंजी बल्कि लंबी होनी चाहिए और जारीकर्ता सेवा का एक पता है:
```
...
,"Tokens": {
    "Key": "Rather_very_long_key",
    "Issuer": "http://localhost:56268/"
}
...
```
!!! वास्तविक परियोजना में, कुंजी को appsettings.json फ़ाइल में न रखें। इसे पर्यावरण चर में रखा जाना चाहिए और इसे इस तरह लेना चाहिए:
```
Environment.GetEnvironmentVariable("JWT_KEY");
```

अद्यतन : .net कोर सेटिंग्स कैसे काम करती हैं, यह देखते हुए, आपको इसे पर्यावरण से बिल्कुल लेने की आवश्यकता नहीं है। आप सेटिंग का उपयोग कर सकते हैं। हालांकि, इसके बजाय हम उत्पादन में पर्यावरण चर को इस चर को लिख सकते हैं, फिर हमारा कोड कॉन्फ़िगरेशन के बजाय पर्यावरण चर को पसंद करेगा।

AuthRequest.cs: लॉगिन और पासवर्ड पास करने के लिए मान रखना:

public class AuthRequest
{
    public string UserName { get; set; }
    public string Password { get; set; }
}

Startup.cs कॉन्फ़िगर में () विधि BEFORE app.UseMvc ():
```
app.UseAuthentication();
```

कॉन्फ़िगर सेवा में Startup.cs ():

services.AddAuthentication()
    .AddJwtBearer(cfg =>
    {
        cfg.RequireHttpsMetadata = false;
        cfg.SaveToken = true;

        cfg.TokenValidationParameters = new TokenValidationParameters()
        {
            ValidIssuer = Configuration["Tokens:Issuer"],
            ValidAudience = Configuration["Tokens:Issuer"],
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Tokens:Key"]))
        };

    });

एक नियंत्रक जोड़ें:

    [Route("api/[controller]")]
    public class TokenController : Controller
    {
        private readonly IConfiguration _config;
        private readonly IUserManager _userManager;

        public TokenController(IConfiguration configuration, IUserManager userManager)
        {
            _config = configuration;
            _userManager = userManager;
        }

        [HttpPost("")]
        [AllowAnonymous]
        public IActionResult Login([FromBody] AuthRequest authUserRequest)
        {
            var user = _userManager.FindByEmail(model.UserName);

            if (user != null)
            {
                var checkPwd = _signInManager.CheckPasswordSignIn(user, model.authUserRequest);
                if (checkPwd)
                {
                    var claims = new[]
                    {
                        new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
                        new Claim(JwtRegisteredClaimNames.Jti, user.Id.ToString()),
                    };

                    var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Tokens:Key"]));
                    var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

                    var token = new JwtSecurityToken(_config["Tokens:Issuer"],
                    _config["Tokens:Issuer"],
                    claims,
                    expires: DateTime.Now.AddMinutes(30),
                    signingCredentials: creds);

                    return Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token) });
                }
            }

            return BadRequest("Could not create token");
        }}

बस आज के लिए इतना ही! चीयर्स!

अपडेट करें: लोग पूछते हैं कि वर्तमान उपयोगकर्ता कैसे प्राप्त करें। करने के लिए:

कॉन्फ़िगर में Startup.cs में () जोड़ें
```
services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
```

नियंत्रक में निर्माता से जोड़ें:

private readonly int _currentUser;
public MyController(IHttpContextAccessor httpContextAccessor)
{
   _currentUser = httpContextAccessor.CurrentUser();
}

कहीं एक एक्सटेंशन जोड़ें और अपने नियंत्रक में इसका उपयोग करें (....)

public static class IHttpContextAccessorExtension
{
    public static int CurrentUser(this IHttpContextAccessor httpContextAccessor)
    {
        var stringId = httpContextAccessor?.HttpContext?.User?.FindFirst(JwtRegisteredClaimNames.Jti)?.Value;
        int.TryParse(stringId ?? "0", out int userId);

        return userId;
    }
}

Question 3

मेरे tokenValidationParametersकाम जब वे इस तरह दिखते हैं:

 var tokenValidationParameters = new TokenValidationParameters
  {
      ValidateIssuerSigningKey = true,
      IssuerSigningKey = GetSignInKey(),
      ValidateIssuer = true,
      ValidIssuer = GetIssuer(),
      ValidateAudience = true,
      ValidAudience = GetAudience(),
      ValidateLifetime = true,
      ClockSkew = TimeSpan.Zero
   };

तथा

    static private SymmetricSecurityKey GetSignInKey()
    {
        const string secretKey = "very_long_very_secret_secret";
        var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secretKey));

        return signingKey;
    }

    static private string GetIssuer()
    {
        return "issuer";
    }

    static private string GetAudience()
    {
        return "audience";
    }

इसके अलावा, विकल्प जोड़ें। RireireHttpsMetadata = false इस तरह:

         .AddJwtBearer(options =>
       {         
           options.TokenValidationParameters =tokenValidationParameters         
           options.RequireHttpsMetadata = false;
       });

संपादित करें :

कॉल करना न भूलें

 app.UseAuthentication();

स्टार्टअप में -> एप्लिकेशन से पहले विधि कॉन्फ़िगर करें । UseMvc ();

Question 4

वेब एपी डेमो के साथ Asp.net Core 2.0 JWT बियरर टोकन प्रमाणीकरण कार्यान्वयन

पैकेज जोड़ें " Microsoft.AspNetCore.Authentication.JwtBearer "

Startup.cs कन्फिगरसर्विसेज ()

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
            .AddJwtBearer(cfg =>
            {
                cfg.RequireHttpsMetadata = false;
                cfg.SaveToken = true;

                cfg.TokenValidationParameters = new TokenValidationParameters()
                {
                    ValidIssuer = "me",
                    ValidAudience = "you",
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("rlyaKithdrYVl6Z80ODU350md")) //Secret
                };

            });

Startup.cs कॉन्फ़िगर करें ()

// ===== Use Authentication ======
        app.UseAuthentication();

User.cs // यह केवल उदाहरण के लिए एक मॉडल वर्ग है। यह कुछ भी हो सकता है।

public class User
{
    public Int32 Id { get; set; }
    public string Username { get; set; }
    public string Country { get; set; }
    public string Password { get; set; }
}

UserContext.cs // यह सिर्फ संदर्भ वर्ग है। यह कुछ भी हो सकता है।

public class UserContext : DbContext
{
    public UserContext(DbContextOptions<UserContext> options) : base(options)
    {
        this.Database.EnsureCreated();
    }

    public DbSet<User> Users { get; set; }
}

AccountController.cs

[Route("[controller]")]
public class AccountController : Controller
{

    private readonly UserContext _context;

    public AccountController(UserContext context)
    {
        _context = context;
    }

    [AllowAnonymous]
    [Route("api/token")]
    [HttpPost]
    public async Task<IActionResult> Token([FromBody]User user)
    {
        if (!ModelState.IsValid) return BadRequest("Token failed to generate");
        var userIdentified = _context.Users.FirstOrDefault(u => u.Username == user.Username);
            if (userIdentified == null)
            {
                return Unauthorized();
            }
            user = userIdentified;

        //Add Claims
        var claims = new[]
        {
            new Claim(JwtRegisteredClaimNames.UniqueName, "data"),
            new Claim(JwtRegisteredClaimNames.Sub, "data"),
            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
        };

        var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("rlyaKithdrYVl6Z80ODU350md")); //Secret
        var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

        var token = new JwtSecurityToken("me",
            "you",
            claims,
            expires: DateTime.Now.AddMinutes(30),
            signingCredentials: creds);

        return Ok(new
        {
            access_token = new JwtSecurityTokenHandler().WriteToken(token),
            expires_in = DateTime.Now.AddMinutes(30),
            token_type = "bearer"
        });
    }
}

UserController.cs

[Authorize]
[Route("api/[controller]")]
public class UserController : ControllerBase
{
    private readonly UserContext _context;

    public UserController(UserContext context)
    {
        _context = context;
        if(_context.Users.Count() == 0 )
        {
            _context.Users.Add(new User { Id = 0, Username = "Abdul Hameed Abdul Sattar", Country = "Indian", Password = "123456" });
            _context.SaveChanges();
        }
    }

    [HttpGet("[action]")]
    public IEnumerable<User> GetList()
    {
        return _context.Users.ToList();
    }

    [HttpGet("[action]/{id}", Name = "GetUser")]
    public IActionResult GetById(long id)
    {
        var user = _context.Users.FirstOrDefault(u => u.Id == id);
        if(user == null)
        {
            return NotFound();
        }
        return new ObjectResult(user);
    }


    [HttpPost("[action]")]
    public IActionResult Create([FromBody] User user)
    {
        if(user == null)
        {
            return BadRequest();
        }

        _context.Users.Add(user);
        _context.SaveChanges();

        return CreatedAtRoute("GetUser", new { id = user.Id }, user);

    }

    [HttpPut("[action]/{id}")]
    public IActionResult Update(long id, [FromBody] User user)
    {
        if (user == null)
        {
            return BadRequest();
        }

        var userIdentified = _context.Users.FirstOrDefault(u => u.Id == id);
        if (userIdentified == null)
        {
            return NotFound();
        }

        userIdentified.Country = user.Country;
        userIdentified.Username = user.Username;

        _context.Users.Update(userIdentified);
        _context.SaveChanges();
        return new NoContentResult();
    }


    [HttpDelete("[action]/{id}")]
    public IActionResult Delete(long id)
    {
        var user = _context.Users.FirstOrDefault(u => u.Id == id);
        if (user == null)
        {
            return NotFound();
        }

        _context.Users.Remove(user);
        _context.SaveChanges();

        return new NoContentResult();
    }
}

पोस्टमैन पर टेस्ट:

अन्य webservices में हैडर में TokenType और AccessToken पास करें।

शुभकामनाएँ! मैं अभी शुरुआत कर रहा हूं। मैं केवल asp.net कोर सीखने शुरू करने के लिए एक सप्ताह बिताया।

Question 5

यहाँ आप के लिए एक समाधान है।

अपने स्टार्टअप में। सबसे पहले, इसे सेवाओं के रूप में कॉन्फ़िगर करें:

  services.AddAuthentication().AddJwtBearer(cfg =>
        {
            cfg.RequireHttpsMetadata = false;
            cfg.SaveToken = true;
            cfg.TokenValidationParameters = new TokenValidationParameters()
            {
                IssuerSigningKey = "somethong",
                ValidAudience = "something",
                :
            };
        });

दूसरा, इस सेवाओं को कॉन्फिग में कॉल करें

          app.UseAuthentication();

अब आप विशेषता जोड़कर अपने नियंत्रक में इसका उपयोग कर सकते हैं

          [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
          [HttpGet]
          public IActionResult GetUserInfo()
          {

पूर्ण विवरण स्रोत कोड के लिए जो कोणीय के रूप में Frond-end का उपयोग करते हैं, यहां देखें

Question 6

यहाँ .Net कोर 2.0 एपीआई के लिए मेरा कार्यान्वयन है:

    public IConfigurationRoot Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        // Add framework services
        services.AddMvc(
        config =>
        {
            // This enables the AuthorizeFilter on all endpoints
            var policy = new AuthorizationPolicyBuilder()
                                .RequireAuthenticatedUser()
                                .Build();
            config.Filters.Add(new AuthorizeFilter(policy));
            
        }
        ).AddJsonOptions(opt =>
        {
            opt.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
        });

        services.AddLogging();

        services.AddAuthentication(sharedOptions =>
        {
            sharedOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
            sharedOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
        })
        .AddJwtBearer(options =>
        {
            options.Audience = Configuration["AzureAD:Audience"];  
            options.Authority = Configuration["AzureAD:AADInstance"] + Configuration["AzureAD:TenantId"];
        });            
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        app.UseAuthentication(); // THIS METHOD MUST COME BEFORE UseMvc...() !!
        app.UseMvcWithDefaultRoute();            
    }

appsettings.json:

{
  "AzureAD": {
    "AADInstance": "https://login.microsoftonline.com/",
    "Audience": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "ClientId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "Domain": "mydomain.com",
    "TenantId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
  },
  ...
}

उपरोक्त कोड सभी नियंत्रकों पर स्थिति को सक्षम करता है। अनाम पहुँच की अनुमति देने के लिए आप पूरे नियंत्रक को सजा सकते हैं:

[Route("api/[controller]")]
[AllowAnonymous]
public class AnonymousController : Controller
{
    ...
}

या केवल एक ही समापन बिंदु को अनुमति देने के लिए एक विधि को सजाने के लिए:

    [AllowAnonymous]
    [HttpPost("anonymousmethod")]
    public async Task<IActionResult> MyAnonymousMethod()
    {
        ...
    }

टिप्पणियाँ:

यह मेरा पहला प्रयास है। यदि कुछ गलत है, तो कृपया मुझे बताएं!
Audienceक्लाइंट द्वारा अनुरोधित संसाधन आईडी से मेल खाना चाहिए । हमारे मामले में हमारे ग्राहक (एक कोणीय वेब ऐप) को अलग-अलग एज़्योर एडी में पंजीकृत किया गया था, और इसने अपने क्लाइंट आईडी का उपयोग किया था, जिसे हमने एपीआई में ऑडियंस के रूप में पंजीकृत किया था।
ClientIdएप्लिकेशन को Azure पोर्टल में एप्लिकेशन आईडी कहा जाता है (क्यों ??), एपीआई के लिए एप्लिकेशन पंजीकरण की एप्लीकेशन आईडी।
TenantIdAzure पोर्टल (क्यों ??) में डायरेक्टरी आईडी कहा जाता है , Azure एक्टिव डायरेक्टरी> प्रॉपर्टीज के अंतर्गत पाया जाता है
यदि API को Azure होस्ट किए गए वेब ऐप के रूप में परिनियोजित किया जाता है, तो सुनिश्चित करें कि आप एप्लिकेशन सेटिंग सेट करें:

जैसे। AzureAD: ऑडियंस / xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

Question 7

बस @alerya द्वारा उत्कृष्ट उत्तर पर अद्यतन करने के लिए मुझे इस तरह दिखने के लिए सहायक वर्ग को संशोधित करना पड़ा;

public static class IHttpContextAccessorExtension
    {
        public static string CurrentUser(this IHttpContextAccessor httpContextAccessor)
        {           
            var userId = httpContextAccessor?.HttpContext?.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value; 
            return userId;
        }
    }

तब मैं अपनी सेवा परत में userId प्राप्त कर सकता था। मुझे पता है कि यह नियंत्रक में आसान है, लेकिन एक चुनौती और नीचे है।