การรับรองความถูกต้องโดยใช้โทเค็นใน ASP.NET Core


161

ฉันทำงานกับแอปพลิเคชัน ASP.NET Core ฉันกำลังพยายามใช้การรับรองความถูกต้องโดยใช้ Token แต่ไม่สามารถหาวิธีใช้ระบบรักษาความปลอดภัยใหม่สำหรับกรณีของฉันได้ ฉันดูตัวอย่างแล้วแต่พวกเขาก็ไม่ได้ช่วยอะไรมากพวกเขาใช้การตรวจสอบความถูกต้องคุกกี้หรือการตรวจสอบภายนอก (GitHub, Microsoft, Twitter)

สถานการณ์ของฉันคืออะไร: แอปพลิเคชัน angularjs ควรขอ/tokenชื่อผู้ใช้และรหัสผ่าน URL ที่ผ่าน WebApi ควรอนุญาตผู้ใช้และส่งคืนaccess_tokenซึ่งแอป angularjs จะใช้ในคำขอต่อไปนี้

ฉันได้พบบทความที่ยอดเยี่ยมเกี่ยวกับการใช้สิ่งที่ฉันต้องการใน ASP.NET - Token Based Authentication โดยใช้ ASP.NET Web API 2, Owin และ Identityรุ่นปัจจุบัน แต่ไม่ชัดเจนสำหรับฉันว่าจะทำสิ่งเดียวกันใน ASP.NET Core ได้อย่างไร

คำถามของฉันคือ: วิธีการกำหนดค่าแอปพลิเคชัน ASP.NET Core WebApi ให้ทำงานกับการตรวจสอบความถูกต้องด้วยโทเค็น


ฉันมีปัญหาเดียวกันและฉันกำลังวางแผนที่จะทำทุกอย่างด้วยตัวเอง FYI มีคำถามอีกคำถามหนึ่งคือ stackoverflow.com/questions/29055477//แต่ไม่มีผู้ให้คำปรึกษาลองดูว่าเกิดอะไรขึ้น
Son_of_Sam


ฉันกำลังเผชิญปัญหาเดียวกัน แต่ยังหาวิธีแก้ปัญหาไม่ได้ ... ฉันต้องเขียนการรับรองความถูกต้องที่กำหนดเองโดยใช้บริการอื่นซึ่งรับรองโทเค็นของฉัน
Mayank Gupta

คำตอบ:


137

อัพเดตสำหรับ. Net Core 3.1:

เดวิดฟาวเลอร์ (สถาปนิกสำหรับทีม ASP .NET แกน) ได้ใส่กันชุดที่เรียบง่ายอย่างไม่น่าเชื่อของการใช้งานรวมทั้งโปรแกรมที่ง่ายแสดงให้เห็นถึง JWT ฉันจะรวมการอัปเดตและสไตล์ที่เรียบง่ายของเขากับโพสต์นี้ในไม่ช้า

อัพเดตสำหรับ. Net Core 2:

รุ่นก่อนหน้าของคำตอบนี้ใช้ RSA ไม่จำเป็นจริงๆหากรหัสเดียวกันกับที่สร้างโทเค็นนั้นเป็นการตรวจสอบโทเค็นด้วย Microsoft.IdentityModel.Tokens.RsaSecurityKeyแต่ถ้าคุณกำลังกระจายความรับผิดชอบของคุณอาจยังคงต้องการที่จะทำเช่นนี้โดยใช้ตัวอย่างของ

  1. สร้างค่าคงที่สองสามอย่างที่เราจะใช้ในภายหลัง นี่คือสิ่งที่ฉันทำ:

    const string TokenAudience = "Myself";
    const string TokenIssuer = "MyProject";
  2. เพิ่มสิ่งนี้ไปยัง Startup.cs ของConfigureServicesคุณ เราจะใช้การฉีดอ้างอิงภายหลังเพื่อเข้าถึงการตั้งค่าเหล่านี้ ฉันสมมติว่าคุณauthenticationConfigurationเป็นConfigurationSectionหรือConfigurationวัตถุเช่นนั้นคุณสามารถมีการกำหนดค่าที่แตกต่างกันสำหรับการแก้ปัญหาและการผลิต ตรวจสอบให้แน่ใจว่าคุณเก็บกุญแจไว้อย่างปลอดภัย! มันสามารถเป็นสตริงใด ๆ

    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;
        });

    ฉันเคยเห็นคำตอบอื่น ๆ เปลี่ยนการตั้งค่าอื่น ๆ เช่นClockSkew; ค่าเริ่มต้นถูกตั้งค่าให้ใช้งานได้กับสภาพแวดล้อมแบบกระจายที่นาฬิกาไม่ตรงกัน นี่คือการตั้งค่าเดียวที่คุณต้องเปลี่ยน

  3. ตั้งค่าการรับรองความถูกต้อง คุณควรจะมีเส้นนี้ก่อนตัวกลางใด ๆ ที่ต้องใช้ของข้อมูลเช่นUserapp.UseMvc()

    app.UseAuthentication();

    โปรดทราบว่าสิ่งนี้จะไม่ทำให้โทเค็นของคุณถูกปล่อยออกมากับSignInManagerสิ่งอื่นใด คุณจะต้องจัดเตรียมกลไกของคุณเองสำหรับการส่งออก JWT ของคุณ - ดูด้านล่าง

  4. AuthorizationPolicyคุณอาจต้องการที่จะระบุ นี้จะช่วยให้คุณสามารถระบุและควบคุมการกระทำที่เพียง [Authorize("Bearer")]แต่ช่วยให้ผู้ถือโทเค็นการตรวจสอบการใช้

    services.AddAuthorization(auth =>
    {
        auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
            .AddAuthenticationTypes(JwtBearerDefaults.AuthenticationType)
            .RequireAuthenticatedUser().Build());
    });
  5. นี่คือส่วนที่ยุ่งยาก: สร้างโทเค็น

    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);
        }
    }

    จากนั้นในคอนโทรลเลอร์ที่คุณต้องการโทเค็นของคุณมีดังนี้:

    [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);
    }

    ที่นี่ฉันสมมติว่าคุณมีเงินต้นอยู่แล้ว หากคุณกำลังใช้เอกลักษณ์ของคุณสามารถใช้IUserClaimsPrincipalFactory<>ในการแปลงของคุณเป็นUserClaimsPrincipal

  6. ในการทดสอบ : รับสัญญาณใส่ลงในแบบฟอร์มที่jwt.io คำแนะนำที่ฉันให้ไว้ข้างต้นช่วยให้คุณสามารถใช้ความลับจากการกำหนดค่าของคุณเพื่อตรวจสอบลายเซ็นได้!

  7. หากคุณแสดงผลนี้ในมุมมองบางส่วนในหน้า HTML ของคุณร่วมกับการรับรองความถูกต้องเฉพาะผู้ถือใน. Net 4.5 คุณสามารถใช้ a ViewComponentเพื่อทำสิ่งเดียวกันได้ ส่วนใหญ่จะเป็นรหัสเดียวกันกับ Controller Action ด้านบน


1
คุณจะต้องฉีดจริง ๆIOptions<OAuthBearerAuthenticationOptions>เพื่อใช้ตัวเลือก ไม่สนับสนุนการใช้วัตถุตัวเลือกโดยตรงเนื่องจากการกำหนดค่าที่กำหนดชื่อซึ่งได้รับการสนับสนุนโดยกรอบตัวเลือกรูปแบบ
Matt DeKrey

2
อัปเดตกับสิ่งที่ฉันใช้ แต่ตอนนี้คำตอบควรได้รับการเขียนซ้ำ ขอบคุณสำหรับ poking ฉัน!
Matt DeKrey

5
# 5 ได้ถูกเปลี่ยนเป็นสิ่งต่อไปนี้ใน Microsoft.AspNet.Authentication.OAuthBearer - เบต้า 5 - 6 และอาจเป็นเบต้าก่อนหน้านี้ แต่ยังไม่ได้รับการยืนยัน auth.AddPolicy ("ผู้ถือ", AuthorizationPolicyBuilder ใหม่ () .AddAuthenticationSchemes (OAuthBearerAuthenticationDefaults.AuthenticationScheme) .RequireAuthenticatedUser (). สร้าง ().
dynamiclynk

5
@MattDeKrey ฉันใช้คำตอบนี้เป็นจุดเริ่มต้นสำหรับตัวอย่างของการรับรองความถูกต้องโดยใช้โทเค็นอย่างง่ายและอัปเดตให้ทำงานกับเบต้า 7 - ดูgithub.com/mrsheepuk/ASPNETSelfCreatedTokenAuthExample - ยังรวมเอาตัวชี้บางอย่างจากความคิดเห็นเหล่านี้
Mark Hughes

2
อัปเดตอีกครั้งสำหรับ RC1 - เวอร์ชันเก่าสำหรับBeta7และBeta8พร้อมใช้งานในสาขาใน GitHub
Mark Hughes

83

ทำงานจากคำตอบที่ยอดเยี่ยมของ Matt Dekreyฉันได้สร้างตัวอย่างการพิสูจน์ตัวตนที่ใช้โทเค็นอย่างสมบูรณ์โดยทำงานกับ ASP.NET Core (1.0.1) คุณสามารถค้นหาโค้ดเต็มรูปแบบในพื้นที่เก็บข้อมูลนี้บน GitHub (สาขาทางเลือกสำหรับ1.0.0-RC1 , beta8 , beta7 ) แต่ในช่วงสั้น ๆ , ขั้นตอนที่สำคัญ ได้แก่ :

สร้างรหัสสำหรับแอปพลิเคชันของคุณ

ในตัวอย่างของฉันฉันสร้างคีย์สุ่มทุกครั้งที่แอปเริ่มต้นคุณจะต้องสร้างและเก็บรหัสไว้ที่ใดที่หนึ่งและมอบให้แอปพลิเคชันของคุณ ดูไฟล์นี้สำหรับวิธีที่ฉันสร้างคีย์สุ่มและวิธีที่คุณอาจนำเข้าจากไฟล์ . json ตามที่แนะนำในความคิดเห็นโดย @kspearrin API การป้องกันข้อมูลดูเหมือนจะเป็นตัวเลือกที่เหมาะสมที่สุดสำหรับการจัดการคีย์ "ถูกต้อง" แต่ฉันยังไม่ได้ผลถ้าเป็นไปได้ กรุณาส่งคำขอดึงถ้าคุณทำมันออกมา!

Startup.cs - กำหนดค่าบริการ

ที่นี่เราต้องโหลดคีย์ส่วนตัวเพื่อให้โทเค็นของเราลงชื่อด้วยซึ่งเราจะใช้ในการตรวจสอบโทเค็นตามที่ปรากฏ เรากำลังจัดเก็บคีย์ไว้ในตัวแปรระดับชั้นเรียนkeyซึ่งเราจะนำกลับมาใช้ใหม่ในวิธีการกำหนดค่าด้านล่าง TokenAuthOptionsเป็นคลาสที่เรียบง่ายซึ่งมีเอกลักษณ์ในการเซ็นชื่อผู้ชมและผู้ออกหลักทรัพย์ที่เราต้องการใน TokenController เพื่อสร้างกุญแจของเรา

// 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());
});

นอกจากนี้เรายังได้กำหนดนโยบายการอนุญาตเพื่อให้เราสามารถใช้[Authorize("Bearer")]กับอุปกรณ์ปลายทางและชั้นเรียนที่เราต้องการปกป้อง

Startup.cs - กำหนดค่า

ที่นี่เราจำเป็นต้องกำหนดค่า 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

ในตัวควบคุมโทเค็นคุณต้องมีวิธีในการสร้างคีย์ที่เซ็นชื่อโดยใช้คีย์ที่โหลดใน Startup.cs เราได้ลงทะเบียนอินสแตนซ์ของ TokenAuthOptions ใน Startup แล้วดังนั้นเราจึงจำเป็นต้องฉีดมันลงใน Constructor ของ TokenController:

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

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

จากนั้นคุณจะต้องสร้างโทเค็นในตัวจัดการของคุณสำหรับจุดสิ้นสุดการเข้าสู่ระบบในตัวอย่างของฉันฉันใช้ชื่อผู้ใช้และรหัสผ่านและตรวจสอบผู้ใช้โดยใช้คำสั่ง if แต่สิ่งสำคัญที่คุณต้องทำคือสร้างหรือโหลดการอ้างสิทธิ์ ประจำตัวที่ใช้และสร้างโทเค็นสำหรับที่:

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);
}

และที่ควรจะเป็น เพียงเพิ่ม[Authorize("Bearer")]วิธีหรือคลาสที่คุณต้องการป้องกันและคุณควรได้รับข้อผิดพลาดหากคุณพยายามเข้าถึงโดยไม่มีโทเค็นอยู่ หากคุณต้องการที่จะกลับ 401 แทนของข้อผิดพลาด 500, คุณจะต้องลงทะเบียนจัดการข้อยกเว้นที่กำหนดเองที่ผมมีในตัวอย่างของฉันที่นี่


1
นี่เป็นตัวอย่างที่ยอดเยี่ยมจริง ๆ และรวมชิ้นส่วนที่หายไปทั้งหมดที่ฉันต้องการเพื่อให้ได้ @ ตัวอย่างของ MattDeKrey ให้ทำงานขอบคุณมาก! โปรดทราบว่าทุกคนที่ยังคงกำหนดเป้าหมาย beta7 แทนที่จะเป็น beta8 ยังคงสามารถพบตัวอย่างดังกล่าวในประวัติ GitHub
nickspoon

1
ดีใจที่มันช่วย @nickspoon - หากคุณมีปัญหาใด ๆ กับมันเลยให้ฉันรู้หรือป๊อปในคำขอดึงบน github และฉันจะอัปเดต!
Mark Hughes

2
ขอบคุณสำหรับสิ่งนี้ แต่ฉันไม่เข้าใจว่าทำไมบางสิ่งบางอย่างที่ทำงานนอกกรอบใน ASP.Net 4 Web API ตอนนี้ต้องมีการกำหนดค่าค่อนข้างน้อยใน ASP.Net 5 ดูเหมือนว่าย้อนกลับไป
JMK

1
ฉันคิดว่าพวกเขากำลังผลักดัน "social auth" สำหรับ ASP.NET 5 ซึ่งทำให้รู้สึกบางอย่างที่ฉันคิด แต่มีแอปพลิเคชันที่ไม่เหมาะสมดังนั้นฉันไม่แน่ใจว่าฉันเห็นด้วยกับทิศทางของพวกเขา @JMK
Mark Hughes

1
@YuriyP ฉันต้องอัปเดตคำตอบนี้สำหรับ RC2 - ฉันยังไม่ได้อัปเดตแอปภายในของเราซึ่งใช้สิ่งนี้กับ RC2 ดังนั้นฉันจึงไม่แน่ใจว่าเกี่ยวข้องกับอะไร ฉันจะอัปเดตเมื่อฉันแก้ไขข้อแตกต่าง ...
Mark Hughes

3

คุณสามารถดูตัวอย่างการเชื่อมต่อ OpenId ซึ่งแสดงวิธีจัดการกับกลไกการพิสูจน์ตัวตนที่แตกต่างกันรวมถึงโทเค็น JWT:

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

หากคุณดูโครงการ Cordova Backend การกำหนดค่าสำหรับ API จะเป็นดังนี้:

           // 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"
            });
        });

ตรรกะใน /Providers/AuthorizationProvider.cs และ RessourceController ของโครงการนั้นก็คุ้มค่าที่จะดูเช่นกัน;)

หรือคุณสามารถใช้รหัสต่อไปนี้เพื่อตรวจสอบโทเค็น (มีตัวอย่างเพื่อให้ทำงานกับ 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);
                }
            };
        });

สำหรับการออกโทเค็นคุณสามารถใช้แพ็คเกจเซิร์ฟเวอร์ openId Connect ดังนี้:

        // 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...;
        });

แก้ไข: ฉันได้ใช้แอพพลิเคชั่นหน้าเดียวที่มีการใช้การตรวจสอบความถูกต้องด้วยโทเค็นโดยใช้เฟรมเวิร์กเอนด์ Aurelia และ ASP.NET core นอกจากนี้ยังมีการเชื่อมต่อสัญญาณ R ถาวร อย่างไรก็ตามฉันยังไม่ได้ใช้งานฐานข้อมูลใด ๆ รหัสสามารถดูได้ที่นี่: https://github.com/alexandre-spieser/AureliaAspNetCoreAuth

หวังว่าจะช่วยได้

ที่ดีที่สุด

อเล็กซ์


1

ดู OpenIddict - เป็นโครงการใหม่ (ณ เวลาที่เขียน) ซึ่งทำให้ง่ายต่อการกำหนดค่าการสร้างโทเค็น JWT และรีเฟรชโทเค็นโทเค็นใน ASP.NET 5 การตรวจสอบโทเค็นถูกจัดการโดยซอฟต์แวร์อื่น

สมมติว่าคุณใช้IdentityกับEntity Frameworkบรรทัดสุดท้ายคือสิ่งที่คุณต้องการเพิ่มในConfigureServicesวิธีการของคุณ:

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

ในConfigureคุณตั้งค่า OpenIddict เพื่อแสดงโทเค็น JWT:

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;
});

คุณยังกำหนดค่าการตรวจสอบความถูกต้องของโทเค็นใน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/";
});

มีสิ่งเล็ก ๆ น้อย ๆ หนึ่งหรือสองอย่างเช่น DbContext ของคุณต้องได้รับมาจาก OpenIddictContext

คุณสามารถดูคำอธิบายแบบเต็มความยาวได้ที่โพสต์บล็อกนี้: http://capesean.co.za/blog/asp-net-5-jwt-tokens/

ตัวอย่างการทำงานสามารถดูได้ที่: https://github.com/capesean/openiddict-test

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.