ASP.NET पहचान में दावा कैसे अपडेट करें?


93

मैं अपने MVC5 प्रोजेक्ट के लिए OWIN प्रमाणीकरण का उपयोग कर रहा हूं। यह मरा हैSignInAsync

 private async Task SignInAsync(ApplicationUser user, bool isPersistent)
        {
            var AccountNo = "101";
            AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
            var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
            identity.AddClaim(new Claim(ClaimTypes.UserData, AccountNo));
            AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent, RedirectUri="Account/Index"}, identity);
        }

जैसा कि आप देख सकते हैं, मैंने AccountNoदावा सूची में जोड़ा ।

अब, मैं अपने आवेदन में किसी बिंदु पर इस दावे को कैसे अपडेट कर सकता हूं? अब तक, मेरे पास यह है:

 public string AccountNo
        {

            get
            {
                var CP = ClaimsPrincipal.Current.Identities.First();
                var Account= CP.Claims.FirstOrDefault(p => p.Type == ClaimTypes.UserData);
                return Account.Value;
            }
            set
            {
                var CP = ClaimsPrincipal.Current.Identities.First();
                var AccountNo= CP.Claims.FirstOrDefault(p => p.Type == ClaimTypes.UserData).Value;
                CP.RemoveClaim(new Claim(ClaimTypes.UserData,AccountNo));
                CP.AddClaim(new Claim(ClaimTypes.UserData, value));
            }

        }

जब मैं दावे को हटाने की कोशिश करता हूं, मुझे यह अपवाद मिलता है:

दावा ' http://schemas.microsoft.com/ws/2008/06/identity/claims/userdata : 101' निकाला नहीं जा सका। यह या तो इस पहचान का हिस्सा नहीं है या यह दावा है कि इस पहचान वाले प्रिंसिपल के स्वामित्व में है। उदाहरण के लिए, प्रिंसिपल भूमिकाओं के साथ एक जेनेरिकप्रिंसिपल बनाते समय दावा खुद करेगा। पहचानकर्ता के माध्यम से भूमिकाओं को उजागर किया जाएगा, लेकिन वास्तव में पहचान के स्वामित्व में नहीं है। इसी तरह का तर्क एक रोलप्रिंसिपल के लिए मौजूद है।

क्या कोई यह जानने में मेरी मदद कर सकता है कि क्लेम को कैसे अपडेट किया जाए?


यदि आप एक दावा में उपयोगकर्ता जानकारी संग्रहीत कर रहे हैं और आप दावा अपडेट करना चाहते हैं, तो एक बार उपयोगकर्ता जानकारी बदल जाने के बाद, आप कॉल कर सकते हैं: SignInManager.SignInAsyncदावे के मूल्य को ताज़ा करने के लिए। इस प्रश्न को
Hooman Bahreini

जवाबों:


123

मैंने दिए गए ClaimsIdentity के आधार पर Add / Update / Read Claims के लिए एक एक्सटेंशन विधि बनाई

namespace Foobar.Common.Extensions
{
    public static class Extensions
    {
            public static void AddUpdateClaim(this IPrincipal currentPrincipal, string key, string value)
            {
                var identity = currentPrincipal.Identity as ClaimsIdentity;
                if (identity == null)
                    return;

                // check for existing claim and remove it
                var existingClaim = identity.FindFirst(key);
                if (existingClaim != null)
                    identity.RemoveClaim(existingClaim);

                // add new claim
                identity.AddClaim(new Claim(key, value));
                var authenticationManager = HttpContext.Current.GetOwinContext().Authentication;
                authenticationManager.AuthenticationResponseGrant = new AuthenticationResponseGrant(new ClaimsPrincipal(identity), new AuthenticationProperties() { IsPersistent = true });
            }

            public static string GetClaimValue(this IPrincipal currentPrincipal, string key)
            {
                var identity = currentPrincipal.Identity as ClaimsIdentity;
                if (identity == null)
                    return null;

                var claim = identity.Claims.FirstOrDefault(c => c.Type == key);
                return claim.Value;
            }
    }
}

और फिर इसका उपयोग करने के लिए

using Foobar.Common.Extensions;

namespace Foobar.Web.Main.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            // add/updating claims
            User.AddUpdateClaim("key1", "value1");
            User.AddUpdateClaim("key2", "value2");
            User.AddUpdateClaim("key3", "value3");
        }

        public ActionResult Details()
        {
            // reading a claim
            var key2 = User.GetClaim("key2");           
        }
    }
}

आखिरकार। मेरे पास इसका एक और समाधान था और यह काम कर रहा था ... ज्यादातर। लेकिन अंततः इस पद्धति पर स्विच कर दिया क्योंकि यह हमेशा काम करने लगता है। धन्यवाद!
saml

3
किसी के पास Asp.Net One Core के लिए समान समाधान है?
मार्टिन

यह केवल वर्तमान एप्लिकेशन के लिए काम करता प्रतीत होता है। मैं एसएसओ सर्वर द्वारा जारी किए गए कुकी को अपडेट करना चाहूंगा ताकि अन्य ऐप भी उन तक पहुंच सकें। कोई विचार कैसे? धन्यवाद
जो कोई भी

@ जब भी कुकी को SSO सर्वर द्वारा यह दिखाने के लिए हस्ताक्षरित किया जाता है कि यह छेड़छाड़ नहीं की गई है (और इस तरह भरोसा किया जा सकता है), मुझे आश्चर्य होगा कि इसे प्राप्त करने का कोई तरीका था क्योंकि यह छेड़छाड़ होगी।
मोगा 05

2
var क्लेम = आइडेंटिटी.कैलाम.फर्स्ट (c => c.Type == key); वापसी का दावा। वाल्यू; वैर क्लेम होना चाहिए। पहचान। बलाएं।फर्स्टऑर्फडफॉल्ट (सी => सी.टाइप == कुंजी); वापसी का दावा।
लीहुआंगबो

57

आप एक नया बना सकते हैं ClaimsIdentityऔर फिर दावों को ऐसे अपडेट कर सकते हैं।

set {
    // get context of the authentication manager
    var authenticationManager = HttpContext.GetOwinContext().Authentication;

    // create a new identity from the old one
    var identity = new ClaimsIdentity(User.Identity);

    // update claim value
    identity.RemoveClaim(identity.FindFirst("AccountNo"));
    identity.AddClaim(new Claim("AccountNo", value));

    // tell the authentication manager to use this new identity
    authenticationManager.AuthenticationResponseGrant = 
        new AuthenticationResponseGrant(
            new ClaimsPrincipal(identity),
            new AuthenticationProperties { IsPersistent = true }
        );
}

4
आप दावे को अपडेट कर सकते हैं लेकिन फिर भी उपयोगकर्ता को लॉग आउट करना होगा और अद्यतन पहचान के साथ।
user3210546 20

3
नहीं, यह उपयोगकर्ता को लॉगआउट नहीं करता है, हम सिर्फ उपयोगकर्ता की कुकी को अपडेट कर रहे हैं
इरशू

5
याद रखें कि यह अपडेट केवल पहचान है। यदि आप इन दावों को संग्रहीत करना चाहते हैं और अनुरोध पर उन्हें स्वचालित रूप से लोड करना चाहते हैं, तो आपको उन्हें हटाने और अद्यतन करने के लिए सूदखोर की आवश्यकता है। मुझे कुछ समय लगा! :(
डेनिस वैन डर

3
क्या होगा अगर मेरे पास कुकीज़ बिल्कुल नहीं हैं और केवल एक्सेसटोकन का उपयोग करें? मेरे मामले में दावे अगले अनुरोध पर पहले जैसे ही हैं। मेरे पास दावा करने का एकमात्र तरीका उपयोगकर्ता को लॉगआउट करना है और उसे एक बार फिर से लॉगिन करने के लिए कहना है :-(
नोज़िम तुरकुलोव

1
यह केवल वर्तमान एप्लिकेशन के लिए काम करता प्रतीत होता है। मैं एसएसओ सर्वर द्वारा जारी किए गए कुकी को अपडेट करना चाहूंगा ताकि अन्य ऐप भी उन तक पहुंच सकें। कोई विचार कैसे? धन्यवाद
जो कोई भी

18

पहचान कुकी में परिवर्तन को प्रतिबिंबित करने के लिए (और वैकल्पिक रूप से db तालिका AspNetUserClaims से दावों को हटाने के लिए) एक और (async) दृष्टिकोण, आइडेंटिटी के UserManager और SigninManager का उपयोग करते हुए:

// Get User and a claims-based identity
ApplicationUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
var Identity = new ClaimsIdentity(User.Identity);

// Remove existing claim and replace with a new value
await UserManager.RemoveClaimAsync(user.Id, Identity.FindFirst("AccountNo"));
await UserManager.AddClaimAsync(user.Id, new Claim("AccountNo", value));

// Re-Signin User to reflect the change in the Identity cookie
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);

// [optional] remove claims from claims table dbo.AspNetUserClaims, if not needed
var userClaims = UserManager.GetClaims(user.Id);
if (userClaims.Any())
{
  foreach (var item in userClaims)
  {
    UserManager.RemoveClaim(user.Id, item);
  }
}

यहाँ, मेरे लिए, क्लैम स्थापित करने के SignInAsync() बाद करने के लिए सुराग था ।
एच डॉग

डीबी से दावों को हटाने पर टिप के लिए धन्यवाद। मुझे एहसास हुआ कि मुझे खुद के बाद सफाई की जरूरत है।
उबर श्नोजोज़

13

.Net core 2.1 के साथ नवीनतम Asp.Net आइडेंटिटी का उपयोग करते हुए, मैं निम्नलिखित दावों के साथ उपयोगकर्ता के दावों को अपडेट करने में सक्षम हो रहा हूं।

  1. रजिस्टर करें UserClaimsPrincipalFactoryताकि हर बार SignInManagerउपयोगकर्ता में गाएं, दावे किए जाते हैं।

    services.AddScoped<IUserClaimsPrincipalFactory<ApplicationUser>, UserClaimService>();
    
  2. UserClaimsPrincipalFactory<TUser, TRole>नीचे दिए गए एक कस्टम को लागू करें

    public class UserClaimService : UserClaimsPrincipalFactory<ApplicationUser, ApplicationRole>
    {
        private readonly ApplicationDbContext _dbContext;
    
        public UserClaimService(ApplicationDbContext dbContext, UserManager<ApplicationUser> userManager, RoleManager<ApplicationRole> roleManager, IOptions<IdentityOptions> optionsAccessor) : base(userManager, roleManager, optionsAccessor)
        {
            _dbContext = dbContext;
        }
    
        public override async Task<ClaimsPrincipal> CreateAsync(ApplicationUser user)
        {
            var principal = await base.CreateAsync(user);
    
            // Get user claims from DB using dbContext
    
            // Add claims
            ((ClaimsIdentity)principal.Identity).AddClaim(new Claim("claimType", "some important claim value"));
    
            return principal;
        }
    }
    
  3. बाद में आपके आवेदन में जब आप डीबी में कुछ बदलते हैं और अपने प्रमाणित और उपयोगकर्ता के हस्ताक्षर में यह दर्शाते हैं, निम्नलिखित पंक्तियाँ प्राप्त होती हैं:

    var user = await _userManager.GetUserAsync(User);
    await _signInManager.RefreshSignInAsync(user);
    

यह सुनिश्चित करता है कि उपयोगकर्ता फिर से लॉगिन की आवश्यकता के बिना जानकारी को देख सकता है। मैंने नियंत्रक में परिणाम वापस करने से ठीक पहले इसे रखा ताकि जब ऑपरेशन खत्म हो जाए, सब कुछ सुरक्षित रूप से ताज़ा हो जाए।

मौजूदा दावों को संपादित करने और सुरक्षित कुकी आदि के लिए दौड़ की स्थिति बनाने के बजाय, आप उपयोगकर्ता को चुपचाप साइन इन करें और राज्य को रीफ़्रेश करें :)


धन्यवाद, उसी समस्या का सामना किया और यह समाधान हस्ताक्षरित उपयोगकर्ता के लिए दावों को अद्यतन करने के लिए बेहतर काम करता है।
ameya

धन्यवाद! उसी मुद्दे के साथ-साथ नेट कोर 3.1 में भी सामना किया
केविन ट्रैन

7

मुझे वह अपवाद भी मिलता है और इस तरह की चीजें साफ हो जाती हैं

var identity = User.Identity as ClaimsIdentity;
var newIdentity = new ClaimsIdentity(identity.AuthenticationType, identity.NameClaimType, identity.RoleClaimType);
newIdentity.AddClaims(identity.Claims.Where(c => false == (c.Type == claim.Type && c.Value == claim.Value)));
// the claim has been removed, you can add it with a new value now if desired
AuthenticationManager.SignOut(identity.AuthenticationType);
AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, newIdentity);

4

मेरे परिवर्धन के साथ पुन: प्रयोग करने योग्य दावा करने वाले वर्ग में यहाँ से कुछ उत्तरों को संकलित किया ।

दावे कायम रहे, उपयोगकर्ता कुकी अद्यतन, ताज़ा में साइन इन करें।

कृपया ध्यान दें कि यदि आपने पूर्व को अनुकूलित नहीं किया था तो ApplicationUser को IdentityUser के साथ प्रतिस्थापित किया जा सकता है। इसके अलावा मेरे मामले में विकास के माहौल में थोड़ा अलग तर्क होना चाहिए, इसलिए आप IWebHostEnvironment निर्भरता को दूर करना चाह सकते हैं।

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using YourMvcCoreProject.Models;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Identity;
using Microsoft.Extensions.Hosting;

namespace YourMvcCoreProject.Identity
{
    public class ClaimsManager
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly SignInManager<ApplicationUser> _signInManager;
        private readonly IWebHostEnvironment _env;
        private readonly ClaimsPrincipalAccessor _currentPrincipalAccessor;

        public ClaimsManager(
            ClaimsPrincipalAccessor currentPrincipalAccessor,
            UserManager<ApplicationUser> userManager,
            SignInManager<ApplicationUser> signInManager,
            IWebHostEnvironment env)
        {
            _currentPrincipalAccessor = currentPrincipalAccessor;
            _userManager = userManager;
            _signInManager = signInManager;
            _env = env;
        }

        /// <param name="refreshSignin">Sometimes (e.g. when adding multiple claims at once) it is desirable to refresh cookie only once, for the last one </param>
        public async Task AddUpdateClaim(string claimType, string claimValue, bool refreshSignin = true)
        {
            await AddClaim(
                _currentPrincipalAccessor.ClaimsPrincipal,
                claimType,
                claimValue, 
                async user =>
                {
                    await RemoveClaim(_currentPrincipalAccessor.ClaimsPrincipal, user, claimType);
                },
                refreshSignin);
        }

        public async Task AddClaim(string claimType, string claimValue, bool refreshSignin = true)
        {
            await AddClaim(_currentPrincipalAccessor.ClaimsPrincipal, claimType, claimValue, refreshSignin);
        }

        /// <summary>
        /// At certain stages of user auth there is no user yet in context but there is one to work with in client code (e.g. calling from ClaimsTransformer)
        /// that's why we have principal as param
        /// </summary>
        public async Task AddClaim(ClaimsPrincipal principal, string claimType, string claimValue, bool refreshSignin = true)
        {
            await AddClaim(
                principal,
                claimType,
                claimValue, 
                async user =>
                {
                    // allow reassignment in dev
                    if (_env.IsDevelopment()) 
                        await RemoveClaim(principal, user, claimType);

                    if (GetClaim(principal, claimType) != null)
                        throw new ClaimCantBeReassignedException(claimType);                
                },
                refreshSignin);
        }

        public async Task RemoveClaims(IEnumerable<string> claimTypes, bool refreshSignin = true)
        {
            await RemoveClaims(_currentPrincipalAccessor.ClaimsPrincipal, claimTypes, refreshSignin);
        }

        public async Task RemoveClaims(ClaimsPrincipal principal, IEnumerable<string> claimTypes, bool refreshSignin = true)
        {
            AssertAuthenticated(principal);
            foreach (var claimType in claimTypes)
            {
                await RemoveClaim(principal, claimType);
            }
            // reflect the change in the Identity cookie
            if (refreshSignin)
                await _signInManager.RefreshSignInAsync(await _userManager.GetUserAsync(principal));
        }

        public async Task RemoveClaim(string claimType, bool refreshSignin = true)
        {
            await RemoveClaim(_currentPrincipalAccessor.ClaimsPrincipal, claimType, refreshSignin);
        }

        public async Task RemoveClaim(ClaimsPrincipal principal, string claimType, bool refreshSignin = true)
        {
            AssertAuthenticated(principal);
            var user = await _userManager.GetUserAsync(principal);
            await RemoveClaim(principal, user, claimType);
            // reflect the change in the Identity cookie
            if (refreshSignin)
                await _signInManager.RefreshSignInAsync(user);
        }

        private async Task AddClaim(ClaimsPrincipal principal, string claimType, string claimValue, Func<ApplicationUser, Task> processExistingClaims, bool refreshSignin)
        {
            AssertAuthenticated(principal);
            var user = await _userManager.GetUserAsync(principal);
            await processExistingClaims(user);
            var claim = new Claim(claimType, claimValue);
            ClaimsIdentity(principal).AddClaim(claim);
            await _userManager.AddClaimAsync(user, claim);
            // reflect the change in the Identity cookie
            if (refreshSignin)
                await _signInManager.RefreshSignInAsync(user);
        }

        /// <summary>
        /// Due to bugs or as result of debug it can be more than one identity of the same type.
        /// The method removes all the claims of a given type.
        /// </summary>
        private async Task RemoveClaim(ClaimsPrincipal principal, ApplicationUser user, string claimType)
        {
            AssertAuthenticated(principal);
            var identity = ClaimsIdentity(principal);
            var claims = identity.FindAll(claimType).ToArray();
            if (claims.Length > 0)
            {
                await _userManager.RemoveClaimsAsync(user, claims);
                foreach (var c in claims)
                {
                    identity.RemoveClaim(c);
                }
            }
        }

        private static Claim GetClaim(ClaimsPrincipal principal, string claimType)
        {
            return ClaimsIdentity(principal).FindFirst(claimType);    
        }    

        /// <summary>
        /// This kind of bugs has to be found during testing phase
        /// </summary>
        private static void AssertAuthenticated(ClaimsPrincipal principal)
        {
            if (!principal.Identity.IsAuthenticated)
                throw new InvalidOperationException("User should be authenticated in order to update claims");
        }

        private static ClaimsIdentity ClaimsIdentity(ClaimsPrincipal principal)
        {
            return (ClaimsIdentity) principal.Identity;
        }
    }


    public class ClaimCantBeReassignedException : Exception
    {
        public ClaimCantBeReassignedException(string claimType) : base($"{claimType} can not be reassigned")
        {
        }
    }

public class ClaimsPrincipalAccessor
{
    private readonly IHttpContextAccessor _httpContextAccessor;

    public ClaimsPrincipalAccessor(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }

    public ClaimsPrincipal ClaimsPrincipal => _httpContextAccessor.HttpContext.User;
}

// to register dependency put this into your Startup.cs and inject ClaimsManager into Controller constructor (or other class) the in same way as you do for other dependencies    
public class Startup
{
    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        services.AddTransient<ClaimsPrincipalAccessor>();
        services.AddTransient<ClaimsManager>();
    }
}

}


2

जब मैं MVC5 का उपयोग करता हूं, और यहां दावा जोड़ें।

public async Task<ClaimsIdentity> GenerateUserIdentityAsync(PATAUserManager manager)
    {
        // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
        var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
        // Add custom user claims here
        userIdentity.AddClaim(new Claim(ClaimTypes.Role, this.Role));

        return userIdentity;
    }

जब मैं SignInAsync फ़ंक्शन में दावे के परिणाम की जांच कर रहा हूं, तो मुझे वैसे भी भूमिका मूल्य का उपयोग नहीं मिल सकता है। परंतु...

इस अनुरोध के समाप्त होने के बाद, मैं अन्य कार्रवाई (अन्य अनुरोध) में भूमिका का उपयोग कर सकता हूं।

 var userWithClaims = (ClaimsPrincipal)User;
        Claim CRole = userWithClaims.Claims.First(c => c.Type == ClaimTypes.Role);

तो, मुझे लगता है कि शायद अतुल्यकालिक कारण IEnumerable प्रक्रिया के पीछे अद्यतन किया गया है।


1

आप एक CookieAuthenticationEventsवर्ग को लागू करके और ओवरराइड करके वर्तमान उपयोगकर्ता के लिए दावे अपडेट कर सकते हैं ValidatePrincipal। वहां आप पुराने दावे को हटा सकते हैं, नया जोड़ सकते हैं, और फिर प्रिंसिपल का उपयोग करके बदल सकते हैं CookieValidatePrincipalContext.ReplacePrincipal। यह डेटाबेस में संग्रहीत किसी भी दावे को प्रभावित नहीं करता है। यह ASP.NET कोर पहचान 2.2 का उपयोग कर रहा है।

public class MyCookieAuthenticationEvents : CookieAuthenticationEvents
{
    string newAccountNo = "102";

    public override Task ValidatePrincipal(CookieValidatePrincipalContext context)
    {
        // first remove the old claim
        var claim = context.Principal.FindFirst(ClaimTypes.UserData);
        if (claim != null)
        {
            ((ClaimsIdentity)context.Principal.Identity).RemoveClaim(claim);
        }

        // add the new claim
        ((ClaimsIdentity)context.Principal.Identity).AddClaim(new Claim(ClaimTypes.UserData, newAccountNo));

        // replace the claims
        context.ReplacePrincipal(context.Principal);
        context.ShouldRenew = true;

        return Task.CompletedTask;
    }
}

आपको ईवेंट की कक्षा को पंजीकृत करने की आवश्यकता है Startup.cs:

public IServiceProvider ConfigureServices(IServiceCollection services)
{
    services.AddScoped<MyCookieAuthenticationEvents>();

    services.ConfigureApplicationCookie(o =>
    {
        o.EventsType = typeof(MyCookieAuthenticationEvents);
    });
}

आप नए AccountNoमूल्य तक पहुंचने के लिए ईवेंट क्लास में सेवाओं को इंजेक्ट कर सकते हैं लेकिन इस पृष्ठ पर चेतावनी के अनुसार आपको कुछ भी महंगा करने से बचना चाहिए:

चेतावनी

यहाँ वर्णित दृष्टिकोण हर अनुरोध पर चालू होता है। हर अनुरोध पर सभी उपयोगकर्ताओं के लिए प्रमाणीकरण कुकीज़ मान्य करने से ऐप के लिए एक बड़ा प्रदर्शन जुर्माना हो सकता है।


धन्यवाद, यह asp.net कोर 3.1 में मेरे लिए बहुत अच्छा काम किया!
अंधेरा ०२

0

डेटाबेस से दावा विवरण निकालने के लिए हम नीचे दिए गए कोड का उपयोग कर सकते हैं। साथ ही, कुकी मूल्यों को अपडेट करने के लिए हमें फिर से साइन इन करना होगा

 // create a new identity 
            var identity = new ClaimsIdentity(User.Identity);

            // Remove the existing claim value of current user from database
            if(identity.FindFirst("NameOfUser")!=null)
                await UserManager.RemoveClaimAsync(applicationUser.Id, identity.FindFirst("NameOfUser"));

            // Update customized claim 
            await UserManager.AddClaimAsync(applicationUser.Id, new Claim("NameOfUser", applicationUser.Name));

            // the claim has been updates, We need to change the cookie value for getting the updated claim
            AuthenticationManager.SignOut(identity.AuthenticationType);
            await SignInManager.SignInAsync(Userprofile, isPersistent: false, rememberBrowser: false);

            return RedirectToAction("Index", "Home");

0

कई कुकीज़, कई दावे

public class ClaimsCookie
    {
        private readonly ClaimsPrincipal _user;
        private readonly HttpContext _httpContext;
        public ClaimsCookie(ClaimsPrincipal user, HttpContext httpContext = null)
        {
            _user = user;
            _httpContext = httpContext;
        }

        public string GetValue(CookieName cookieName, KeyName keyName)
        {
            var principal = _user as ClaimsPrincipal;
            var cp = principal.Identities.First(i => i.AuthenticationType == ((CookieName)cookieName).ToString());
            return cp.FindFirst(((KeyName)keyName).ToString()).Value;
        }
        public async void SetValue(CookieName cookieName, KeyName[] keyName, string[] value)
        {
            if (keyName.Length != value.Length)
            {
                return;
            }
            var principal = _user as ClaimsPrincipal;
            var cp = principal.Identities.First(i => i.AuthenticationType == ((CookieName)cookieName).ToString());
            for (int i = 0; i < keyName.Length; i++)
            {
                if (cp.FindFirst(((KeyName)keyName[i]).ToString()) != null)
                {
                    cp.RemoveClaim(cp.FindFirst(((KeyName)keyName[i]).ToString()));
                    cp.AddClaim(new Claim(((KeyName)keyName[i]).ToString(), value[i]));
                }

            }
            await _httpContext.SignOutAsync(CookieName.UserProfilCookie.ToString());
            await _httpContext.SignInAsync(CookieName.UserProfilCookie.ToString(), new ClaimsPrincipal(cp),
                new AuthenticationProperties
                {
                    IsPersistent = bool.Parse(cp.FindFirst(KeyName.IsPersistent.ToString()).Value),
                    AllowRefresh = true
                });
        }
        public enum CookieName
        {
            CompanyUserProfilCookie = 0, UserProfilCookie = 1, AdminPanelCookie = 2
        }
        public enum KeyName
        {
            Id, Name, Surname, Image, IsPersistent
        }
    }

0
    if (HttpContext.User.Identity is ClaimsIdentity identity)
        {
            identity.RemoveClaim(identity.FindFirst("userId"));
            identity.AddClaim(new Claim("userId", userInfo?.id.ToString()));
            await HttpContext.SignInAsync(
                CookieAuthenticationDefaults.AuthenticationScheme,
                new ClaimsPrincipal(HttpContext.User.Identity));
        }

7
आमतौर पर अनाम कोड की कुछ पंक्तियों को पोस्ट करने के बजाय किसी समाधान की व्याख्या करना बेहतर होता है। आप पढ़ सकते हैं कि मैं एक अच्छा उत्तर कैसे लिखूं , और पूरी तरह से कोड-आधारित उत्तर की व्याख्या
Anh Pham

0

मैं एक .net कोर 2.2 ऐप का उपयोग कर रहा हूं और निम्नलिखित समाधान का उपयोग कर रहा हूं: मेरे स्टेटअप में

public void ConfigureServices(IServiceCollection services)
        {
        ...
           services.AddIdentity<IdentityUser, IdentityRole>(options =>
               {
                  ...
               })
               .AddEntityFrameworkStores<AdminDbContext>()
               .AddDefaultTokenProviders()
               .AddSignInManager();

प्रयोग

  private readonly SignInManager<IdentityUser> _signInManager;


        public YourController(
                                    ...,
SignInManager<IdentityUser> signInManager)
        {
           ...
            _signInManager = signInManager;
        }

 public async Task<IActionResult> YourMethod() // <-NOTE IT IS ASYNC
        {
                var user = _userManager.FindByNameAsync(User.Identity.Name).Result;
                var claimToUse = ClaimsHelpers.CreateClaim(ClaimTypes.ActiveCompany, JsonConvert.SerializeObject(cc));
                var claimToRemove = _userManager.GetClaimsAsync(user).Result
                    .FirstOrDefault(x => x.Type == ClaimTypes.ActiveCompany.ToString());
                if (claimToRemove != null)
                {
                    var result = _userManager.ReplaceClaimAsync(user, claimToRemove, claimToUse).Result;
                    await _signInManager.RefreshSignInAsync(user); //<--- THIS
                }
                else ...
              

-1

एक्सटेंशन मेथड ने मेरे लिए एक अपवाद के साथ बहुत अच्छा काम किया कि अगर उपयोगकर्ता लॉग आउट करता है तो पुराने क्लेम सेट अभी भी मौजूद हैं और एक छोटे से संशोधन के साथ है जैसे कि सब कुछ शानदार काम करता है। मैं सीधे जवाब नहीं दे सकता क्योंकि मेरी प्रतिष्ठा भंग हो गई है :(

public static class ClaimExtensions
{
    public static void AddUpdateClaim(this IPrincipal currentPrincipal,    string key, string value, ApplicationUserManager userManager)
    {
        var identity = currentPrincipal.Identity as ClaimsIdentity;
        if (identity == null)
            return;

        // check for existing claim and remove it
        var existingClaim = identity.FindFirst(key);
        if (existingClaim != null)
        {
            RemoveClaim(currentPrincipal, key, userManager);
        }

        // add new claim
        var claim = new Claim(key, value);
        identity.AddClaim(claim);
        var authenticationManager = HttpContext.Current.GetOwinContext().Authentication;
        authenticationManager.AuthenticationResponseGrant = new AuthenticationResponseGrant(new ClaimsPrincipal(identity), new AuthenticationProperties() { IsPersistent = true });
        //Persist to store
        userManager.AddClaim(identity.GetUserId(),claim);

    }

    public static void RemoveClaim(this IPrincipal currentPrincipal, string key, ApplicationUserManager userManager)
    {
        var identity = currentPrincipal.Identity as ClaimsIdentity;
        if (identity == null)
            return ;

        // check for existing claim and remove it
        var existingClaims = identity.FindAll(key);
        existingClaims.ForEach(c=> identity.RemoveClaim(c));

        //remove old claims from store
        var user = userManager.FindById(identity.GetUserId());
        var claims =  userManager.GetClaims(user.Id);
        claims.Where(x => x.Type == key).ToList().ForEach(c => userManager.RemoveClaim(user.Id, c));

    }

    public static string GetClaimValue(this IPrincipal currentPrincipal, string key)
    {
        var identity = currentPrincipal.Identity as ClaimsIdentity;
        if (identity == null)
            return null;

        var claim = identity.Claims.First(c => c.Type == key);
        return claim.Value;
    }

    public static string GetAllClaims(this IPrincipal currentPrincipal, ApplicationUserManager userManager)
    {
        var identity = currentPrincipal.Identity as ClaimsIdentity;
        if (identity == null)
            return null;

        var claims = userManager.GetClaims(identity.GetUserId());
        var userClaims = new StringBuilder();
        claims.ForEach(c => userClaims.AppendLine($"<li>{c.Type}, {c.Value}</li>"));
        return userClaims.ToString();
    }


}

-2

हेयर यू गो:

            var user = User as ClaimsPrincipal;
            var identity = user.Identity as ClaimsIdentity;
            var claim = (from c in user.Claims
                         where c.Type == ClaimTypes.UserData
                         select c).Single();
            identity.RemoveClaim(claim);

यहां से ले जाया गया

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.