public IAdapterPresentation TryEndAuthentication(IAuthenticationContext context, IProofData proofData, System.Net.HttpListenerRequest request, out System.Security.Claims.Claim[] claims)
{
claims = null;
IAdapterPresentation result = null;
string pin = proofData.Properties["pin"].ToString();
if (pin == "98765")
{
System.Security.Claims.Claim claim = new System.Security.Claims.Claim("http://schemas.microsoft.com/ws/2008/06/identity/claims/authenticationmethod", "http://schemas.microsoft.com/ws/2012/12/authmethod/otp");
claims = new System.Security.Claims.Claim[] { claim };
}
else
{
result = new SimplePINAdapterPresentation("Authentication failed.", false);
}
return result;
}
public async Task<Client> FetchClient(string siteId, string clientId, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var client = await _queries.FetchAsync(siteId, clientId, cancellationToken).ConfigureAwait(false);
if(client != null)
{
var clientClaims = await GetClientClaims(siteId, client.ClientId, cancellationToken).ConfigureAwait(false);
foreach(var cc in clientClaims)
{
var c = new System.Security.Claims.Claim(cc.Type, cc.Value);
client.Claims.Add(c);
}
}
return client;
}
public async Task<Client> FindClientByIdAsync(string clientId)
{
var site = _contextAccessor.HttpContext.GetTenant<SiteContext>();
if (site == null) return null;
var client = await _queries.FetchAsync(
site.Id.ToString(), // aka nodb projectid
clientId
).ConfigureAwait(false);
if (client != null)
{
var clientClaims = await GetClientClaims(site.Id.ToString(), client.ClientId).ConfigureAwait(false);
foreach (var cc in clientClaims)
{
var c = new System.Security.Claims.Claim(cc.Type, cc.Value);
client.Claims.Add(c);
}
}
return client;
}
public bool IsAvailableForUser(Claim identityClaim, IAuthenticationContext context)
{
return(true);
}
public Task ReplaceClaimAsync(ApplicationUser user, System.Security.Claims.Claim claim, System.Security.Claims.Claim newClaim, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public List <long> GetUserIdsByClaim(System.Security.Claims.Claim claim)
{
return(DbSet.Where(x => x.ClaimType == claim.Type && x.ClaimValue == claim.Value).Select(o => o.UserId).ToList());
}
public virtual bool TryRemoveClaim(System.Security.Claims.Claim claim)
{
throw null;
}
public static System.Security.Claims.Claim ToSecurityClaim(this Claim model)
{
System.Security.Claims.Claim claim = null;
if (model != null)
claim = new System.Security.Claims.Claim(model.ClaimType, model.ClaimValue, "http://www.w3.org/2001/XMLSchema#string");
return claim;
}
/// <summary>
/// Uses JwtSecurityTokenHandler.OutboundClaimTypeMap to map claimtype.
/// </summary>
/// <param name="claim"></param>
/// <returns></returns>
public static Claim OutboundClaim( Claim claim )
{
Claim outboundClaim = claim;
if ( JwtSecurityTokenHandler.OutboundClaimTypeMap.ContainsKey( claim.Type ) )
{
outboundClaim = new Claim( JwtSecurityTokenHandler.OutboundClaimTypeMap[claim.Type], claim.Value, claim.ValueType, claim.Issuer, claim.OriginalIssuer, claim.Subject );
foreach ( KeyValuePair< string, string > kv in claim.Properties )
{
outboundClaim.Properties.Add( kv );
}
}
return outboundClaim;
}
public static IEnumerable<Claim> ExpectedInClaimsIdentityUsingAllInboundShortClaimTypes(string issuer, string originalIssuer, IEnumerable<Claim> extraClaims = null)
{
foreach (KeyValuePair<string, string> pair in JwtSecurityTokenHandler.InboundClaimTypeMap)
{
Claim claim = new Claim(pair.Value, pair.Value, ClaimValueTypes.String, issuer, originalIssuer);
claim.Properties.Add(new KeyValuePair<string, string>(JwtSecurityTokenHandler.ShortClaimTypeProperty, pair.Key));
yield return claim;
}
if (extraClaims != null)
{
foreach (Claim c in extraClaims)
{
yield return c;
}
}
}
public System.Threading.Tasks.Task AddClaimAsync(SoftFluent.Samples.AspNetIdentity2.User user, System.Security.Claims.Claim claim)
{
SoftFluent.Samples.AspNetIdentity2.UserClaim userClaim = new SoftFluent.Samples.AspNetIdentity2.UserClaim();
userClaim.User = user;
userClaim.Type = claim.Type;
userClaim.Value = claim.Value;
userClaim.Issuer = claim.Issuer;
userClaim.OriginalIssuer = claim.OriginalIssuer;
userClaim.ValueType = claim.ValueType;
userClaim.Save();
return(System.Threading.Tasks.Task.FromResult(0));
}
protected Claim(System.Security.Claims.Claim other, System.Security.Claims.ClaimsIdentity subject)
{
}
public virtual bool TryRemoveClaim(System.Security.Claims.Claim claim)
{
return(default(bool));
}
public virtual void RemoveClaim(System.Security.Claims.Claim claim)
{
}
protected Claim(System.Security.Claims.Claim other)
{
}
public virtual void AddClaim(System.Security.Claims.Claim claim)
{
}
public async Task ReplaceClaimAsync(DemoIdentityUser user, System.Security.Claims.Claim claim, System.Security.Claims.Claim newClaim, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
throwIfDisposed();
ExceptionUtil.ThrowIfNull(user, nameof(user));
ExceptionUtil.ThrowIfNull(claim, nameof(claim));
ExceptionUtil.ThrowIfNull(newClaim, nameof(newClaim));
var userId = getGuid(user.Id);
var userClaim = (await _unitOfWork.UserClaimRepository.GetByUserIdAsync(userId))
.SingleOrDefault(x => x.Type == claim.Type && x.Value == claim.Value);
if (userClaim != null)
{
userClaim.Type = newClaim.Type;
userClaim.Value = newClaim.Value;
await _unitOfWork.UserClaimRepository.UpdateAsync(userClaim);
await _unitOfWork.CommitAsync();
}
}
private JwtPayload doBuildPayload(PrivateClaims privateClaims, JWTOptions options)
{
JwtPayload payload = new JwtPayload();
// ****START BUILD PAYLOAD****//
// Adding private claims
List <Claim> privateC = privateClaims.getAllClaims();
foreach (Claim privateClaim in privateC)
{
if (privateClaim.getNestedClaims() != null)
{
payload.Add(privateClaim.getKey(), privateClaim.getNestedClaims().getNestedMap());
}
else
{
System.Security.Claims.Claim netPrivateClaim = null;
object obj = privateClaim.getValue();
if (obj.GetType() == typeof(string))
{
netPrivateClaim = new System.Security.Claims.Claim(privateClaim.getKey(), (string)privateClaim.getValue());
}
else if (obj.GetType() == typeof(int))
{
int value = (int)obj;
netPrivateClaim = new System.Security.Claims.Claim(privateClaim.getKey(), value.ToString(), System.Security.Claims.ClaimValueTypes.Integer32);
}
else if (obj.GetType() == typeof(long))
{
long value = (long)obj;
netPrivateClaim = new System.Security.Claims.Claim(privateClaim.getKey(), value.ToString(), System.Security.Claims.ClaimValueTypes.Integer64);
}
else if (obj.GetType() == typeof(double))
{
double value = (double)obj;
netPrivateClaim = new System.Security.Claims.Claim(privateClaim.getKey(), value.ToString(), System.Security.Claims.ClaimValueTypes.Double);
}
else if (obj.GetType() == typeof(bool))
{
bool value = (bool)obj;
netPrivateClaim = new System.Security.Claims.Claim(privateClaim.getKey(), value.ToString(), System.Security.Claims.ClaimValueTypes.Boolean);
}
else
{
this.error.setError("JW012", "Unrecognized data type");
}
//System.Security.Claims.Claim netPrivateClaim = new System.Security.Claims.Claim(privateClaim.getKey(), privateClaim.getValue());
payload.AddClaim(netPrivateClaim);
}
}
// Adding public claims
if (options.hasPublicClaims())
{
PublicClaims publicClaims = options.getAllPublicClaims();
List <Claim> publicC = publicClaims.getAllClaims();
foreach (Claim publicClaim in publicC)
{
System.Security.Claims.Claim netPublicClaim = new System.Security.Claims.Claim(publicClaim.getKey(), (string)publicClaim.getValue());
payload.AddClaim(netPublicClaim);
}
}
// Adding registered claims
if (options.hasRegisteredClaims())
{
RegisteredClaims registeredClaims = options.getAllRegisteredClaims();
List <Claim> registeredC = registeredClaims.getAllClaims();
foreach (Claim registeredClaim in registeredC)
{
System.Security.Claims.Claim netRegisteredClaim;
if (RegisteredClaimUtils.isTimeValidatingClaim(registeredClaim.getKey()))
{
netRegisteredClaim = new System.Security.Claims.Claim(registeredClaim.getKey(), (string)registeredClaim.getValue(), System.Security.Claims.ClaimValueTypes.Integer32);
}
else
{
netRegisteredClaim = new System.Security.Claims.Claim(registeredClaim.getKey(), (string)registeredClaim.getValue());
}
payload.AddClaim(netRegisteredClaim);
}
}
// ****END BUILD PAYLOAD****//
return(payload);
}
public static List<Claim> RoleClaimsLongType(string issuer, string originalIssuer)
{
var claims = new List<Claim>();
var claim = new Claim(ClaimTypes.Role, "role1", ClaimValueTypes.String, issuer, originalIssuer);
claim.Properties.Add(JwtSecurityTokenHandler.ShortClaimTypeProperty, "role");
claims.Add(claim);
claim = new Claim(ClaimTypes.Role, "roles1", ClaimValueTypes.String, issuer, originalIssuer);
claim.Properties.Add(JwtSecurityTokenHandler.ShortClaimTypeProperty, "roles");
claims.Add(claim);
return claims;
}
public System.Threading.Tasks.Task RemoveClaimAsync(SoftFluent.Samples.AspNetIdentity2.User user, System.Security.Claims.Claim claim)
{
SoftFluent.Samples.AspNetIdentity2.UserClaimCollection.DeleteByTypeAndValue(claim.Type, claim.Value);
return(System.Threading.Tasks.Task.FromResult(0));
}
/// <summary>
/// Simulates that a claim arrived and was mapped, adds the short name property for any claims that would have been translated
/// </summary>
/// <param name="claim"></param>
/// <returns></returns>
public static Claim InboundClaim( Claim claim )
{
if ( JwtSecurityTokenHandler.OutboundClaimTypeMap.ContainsKey( claim.Type ) )
{
if ( JwtSecurityTokenHandler.InboundClaimTypeMap.ContainsKey( JwtSecurityTokenHandler.OutboundClaimTypeMap[claim.Type] ) )
{
if ( !claim.Properties.ContainsKey( JwtSecurityTokenHandler.ShortClaimTypeProperty ) )
{
claim.Properties.Add( JwtSecurityTokenHandler.ShortClaimTypeProperty, JwtSecurityTokenHandler.OutboundClaimTypeMap[claim.Type] );
}
}
}
return claim;
}
private static UserInfo GetOrCreateCachedUserInfo(JwtSecurityToken jwt, PortalSettings portalSettings, System.Security.Claims.Claim userClaim)
{
var usernamePrefixEnabled = bool.Parse(AzureConfig.GetSetting(AzureConfig.ServiceName, "UsernamePrefixEnabled", portalSettings.PortalId, "true"));
var usernameToFind = usernamePrefixEnabled ? $"azureb2c-{userClaim.Value}" : userClaim.Value;
var userInfo = UserController.GetUserByName(portalSettings.PortalId, usernameToFind);
var tokenKey = ComputeSha256Hash(jwt.RawData);
var cache = DotNetNuke.Services.Cache.CachingProvider.Instance();
if (string.IsNullOrEmpty((string)cache.GetItem($"SyncB2CToken|{tokenKey}")))
{
var azureClient = new AzureClient(portalSettings.PortalId, AuthMode.Login)
{
JwtIdToken = jwt
};
azureClient.SetAuthTokenInternal(jwt.RawData);
azureClient.SetAutoMatchExistingUsers(true);
var userData = azureClient.GetCurrentUserInternal(jwt);
if (userInfo == null)
{
// If user doesn't exist, create the user
userInfo = userData.ToUserInfo(usernamePrefixEnabled);
userInfo.PortalID = portalSettings.PortalId;
userInfo.Membership.Password = UserController.GeneratePassword();
var result = UserController.CreateUser(ref userInfo);
}
azureClient.AuthenticateUser(userData, portalSettings, HttpContext.Current.Request["REMOTE_ADDR"], azureClient.AddCustomProperties, azureClient.OnUserAuthenticated);
azureClient.UpdateUserProfile(jwt, portalSettings, false, false);
cache.Insert($"SyncB2CToken|{tokenKey}", "OK", null, jwt.ValidTo, TimeSpan.Zero);
}
return(userInfo);
}
public UserHttpContext(string userKey)
{
var claim = new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.NameIdentifier, userKey);
var claimIdentity = new System.Security.Claims.ClaimsIdentity(new List<System.Security.Claims.Claim> { claim }, "Test");
var identity = new System.Security.Claims.ClaimsIdentity[] { claimIdentity };
var principal = new System.Security.Claims.ClaimsPrincipal(identity);
User = principal;
_Request = MockHttpContextFactory.CreateRequest();
_Response = MockHttpContextFactory.CreateResponse();
}
public Task RemoveClaimAsync(User user, Claim claim)
{
var c = user.Claims.FirstOrDefault(l =>
l.Type == claim.Type &&
l.Value == claim.Value
);
if (c != null)
user.Claims.Remove(c);
return Task.FromResult(0);
}
private static System.Security.Claims.ClaimsPrincipal CreateClaimsPrincipal(string userKey)
{
System.Security.Claims.ClaimsIdentity claimIdentity;
if (userKey == null)
{
claimIdentity = new System.Security.Claims.ClaimsIdentity();
}
else
{
var claim = new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.NameIdentifier, userKey);
var claims = new List<System.Security.Claims.Claim> { claim };
claimIdentity = new System.Security.Claims.ClaimsIdentity(claims, "Test");
}
var identity = new System.Security.Claims.ClaimsIdentity[] { claimIdentity };
return new System.Security.Claims.ClaimsPrincipal(identity);
}
Task IUserClaimStore <JoinIdentityUser, int> .RemoveClaimAsync(JoinIdentityUser user, Claim claim) => throw new NotImplementedException();
public Task AddClaimAsync(User user, Claim claim)
{
var c = new Core.Security.Claim();
c.Type = claim.Type;
c.Value = claim.Value;
user.Claims.Add(c);
return Task.FromResult(0);
}
public async Task AddClaimAsync(ApplicationUser user, System.Security.Claims.Claim claim)
{
this.ThrowIfDisposed();
await this._userManagementService.AddClaimAsync(user.ToDomainUser(), claim.ToDomainClaim(), new CancellationToken());
}
public Task <IList <ApplicationUser> > GetUsersForClaimAsync(System.Security.Claims.Claim claim, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
protected virtual void WriteClaim(System.IO.BinaryWriter writer, System.Security.Claims.Claim claim)
{
}
