.NET कोर में मल्टीपिलर ऑथेंटिकेशन मल्टीकॉलर कनेक्ट करना

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

मल्टीएक्टर प्रमाणीकरण के लिए कुछ शब्दों की आवश्यकता क्यों है:

1. सुरक्षा
2. फिर से सुरक्षा
3. सुविधा

हां, आखिरी बिंदु गलती नहीं है। दूसरा और / या तीसरा प्रमाणीकरण कारक न केवल पारंपरिक पासवर्ड के लिए एक अतिरिक्त है, बल्कि एक पूर्ण प्रतिस्थापन भी है। साइट पर बाधित किए जाने वाले कोड के साथ एसएमएस के बजाय, आधुनिक तरीके फोन या लैपटॉप पर एक फिंगरप्रिंट का उपयोग करके कार्रवाई या बॉयोमीट्रिक प्रमाणीकरण की पुष्टि करने के लिए एक बटन के साथ मैसेंजर में PUSH हैं।

संचालन का सिद्धांत

1. साइट उपयोगकर्ता के उपयोगकर्ता नाम / पासवर्ड का अनुरोध और सत्यापन करती है
2. यदि वे सही तरीके से निर्दिष्ट हैं, तो उपयोगकर्ता को दूसरे कारक के माध्यम से प्रमाणीकरण पृष्ठ पर भेजता है
3. एक सफल सत्यापन के बाद, उपयोगकर्ता एक एक्सेस टोकन के साथ साइट पर लौटता है और लॉग इन करता है, अर्थात साइट के बंद हिस्से को देखने की अनुमति प्राप्त करता है।

एक्सेस टोकन

— JWT (JSON Web Token). . , , JSON . : , . base64-url. ,

{
  "typ": "JWT",     // : JWT
  "alg": "HS256"    // : HMAC   SHA-256
}

, , , , . : , claims . , iss, aud, sub .

{
  "iss": "https://access.multifactor.ru",   // 
  "aud": "https://example.com",             // 
  "sub": "user@example.com",                // 
  "jti": "RxMEyo9",                         //id 
  "iat": 1571684399,                        // 
  "exp": 1571684699,                        // 
  "returnUrl": "/",                         // 
  "rememberMe": "False",                    // 
  "createdAt": "10/21/19 6:59:55 PM"        // 
}

JWT — , , HMAC-SHA256(message, secret), :

• message — , base64-url ;
• secret — , , .

JWT , , , , e-mail, .
JWT , , . , .

, ASP.NET Core Web Application. :

3. .

appsettings.json API multifactor.ru

"Multifactor": {
    "ApiKey": "",
    "ApiSecret": "",
    "CallbackUrl": "https://localhost:44300/account/mfa"
  }

• ApiKey ApiSecret
• CallbackUrl —

API

API multifactor.ru

/// <summary>
/// Multifactor Client
/// </summary>
public class MultifactorService
{
    //    API
    private string _apiKey;
    private string _apiSecret;
    private string _callbackUrl;

    private string _apiHost = "https://api.multifactor.ru";

    public MultifactorService(string apiKey, string apiSecret, string callbackUrl)
    {
        _apiKey = apiKey ?? throw new ArgumentNullException(nameof(apiKey));
        _apiSecret = apiSecret ?? throw new ArgumentNullException(nameof(apiSecret));
        _callbackUrl = callbackUrl ?? throw new ArgumentNullException(nameof(callbackUrl));
    }

    public async Task<string> GetAccessPage(string identityName, IDictionary<string, string> claims = null)
    {
        if (string.IsNullOrEmpty(identityName)) throw new ArgumentNullException(nameof(identityName));

        var request = JsonConvert.SerializeObject(new
        {
            Identity = identityName,    //login 
            Callback = new
            {
                Action = _callbackUrl,  // 
                Target = "_self"
            },
            Claims = claims             // 
        });

        var payLoad = Encoding.UTF8.GetBytes(request);

        //basic authorization
        var authHeader = Convert.ToBase64String(Encoding.ASCII.GetBytes(_apiKey + ":" + _apiSecret));

        using var client = new WebClient();
        client.Headers.Add("Authorization", "Basic " + authHeader);
        client.Headers.Add("Content-Type", "application/json");

        var responseData = await client.UploadDataTaskAsync(_apiHost + "/access/requests", "POST", payLoad);
        var responseJson = Encoding.ASCII.GetString(responseData);

        var response = JsonConvert.DeserializeObject<MultifactorResponse<MultifactorAccessPage>>(responseJson);
        return response.Model.Url; //  
    }

    internal class MultifactorResponse<T>
    {
        public bool Success { get; set; }
        public T Model { get; set; }
    }

    internal class MultifactorAccessPage
    {
        public string Url { get; set; }
    }
}

— API . , appsettings.json. GetAccessPage , API .

Startup.cs, ConfigureServices API

//load Multifactor settings
var multifactorSection = Configuration.GetSection("Multifactor");
var apiKey = multifactorSection["ApiKey"];
var apiSecret = multifactorSection["ApiSecret"];
var callbackUrl = multifactorSection["CallbackUrl"];

//register Multifactor service
var multifactorService = new MultifactorService(apiKey, apiSecret, callbackUrl);
services.AddSingleton(multifactorService);

.net core . , . JWT — Bearer . , JWT HTTP "Authorization: Bearer", .NET Core , , .

.net JWT Bearer

services
    .AddAuthentication(x =>
    {
        x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
        x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
    })
    .AddJwtBearer(x =>
    {
        x.RequireHttpsMetadata = true;
        x.SaveToken = true;
        x.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(apiSecret)), //signature validation key
            ValidateIssuer = true,
            ValidIssuer = "https://access.multifactor.ru",
            ValidateAudience = false,
            NameClaimType = ClaimTypes.NameIdentifier
        };
    });

:

• ValidateIssuerSigningKey —
• IssuerSigningKey ApiSecret API
• ValidateIssuer —
• NameClaimType

Middleware

Configure , JWT Bearer

app.Use(async (context, next) =>
    {
        var token = context.Request.Cookies["jwt"];
        if (!string.IsNullOrEmpty(token))
        {
            context.Request.Headers.Add("Authorization", "Bearer " + token);
        }

        await next();
    });

//redirect to /account/login when unauthorized
    app.UseStatusCodePages(async context => {
        var response = context.HttpContext.Response;

        if (response.StatusCode == (int)HttpStatusCode.Unauthorized)
        {
            response.Redirect("/account/login");
        }
    });

AccountController

, . , AccountController, .

API multifactor.ru

private MultifactorService _multifactorService;

[HttpPost("/account/login")]
public async Task<IActionResult> Login([Required]string login, [Required]string password)
{
    if (ModelState.IsValid)
    {
        // identity provider      
        var isValidUser = _identityService.ValidateUser(login, password, out string role);

        if (isValidUser)
        {
            var claims = new Dictionary<string, string> //         ,       
            {
                { "Role", role }
            };

            var url = await _multifactorService.GetAccessPage(login, claims);
            return RedirectPermanent(url);
        }
    }

    return View();
}

—

[HttpPost("/account/mfa")]
public IActionResult MultifactorCallback(string accessToken)
{
    //         
    Response.Cookies.Append("jwt", accessToken);
    return LocalRedirect("/");
}

, , Logout,

[HttpGet("/account/logout")]
public IActionResult Logout()
{
    Response.Cookies.Delete("jwt");
    return Redirect("/");
}

लेख से कोड के साथ एक काम का मसौदा GitHub पर उपलब्ध है । ASP.NET Core में ClaimsIdentity- आधारित प्रमाणीकरण कैसे काम करता है, इसकी गहन समझ के लिए, इस महान लेख को देखें ।