public void When_Passing_Standard_Claims_In_UserInfo_And_Trying_To_Retrieve_The_Names_Then_Names_Are_Returned()
{
// ARRANGE
const string notStandardClaimName = "not_standard";
var claimsParameter = new ClaimsParameter
{
UserInfo = new List <ClaimParameter>
{
new ClaimParameter {
Name = Core.Jwt.Constants.StandardResourceOwnerClaimNames.Subject
},
new ClaimParameter {
Name = notStandardClaimName
}
}
};
// ACT
var claimNames = claimsParameter.GetClaimNames();
// ASSERT
Assert.NotNull(claimNames);
Assert.True(claimNames.Contains(Core.Jwt.Constants.StandardResourceOwnerClaimNames.Subject));
Assert.False(claimNames.Contains(notStandardClaimName));
}
public static AuthorizationParameter ToParameter(this AuthorizationRequest request)
{
var result = new AuthorizationParameter
{
AcrValues = request.AcrValues,
ClientId = request.ClientId,
Display = request.Display == null ? Core.Parameters.Display.page : (Core.Parameters.Display)request.Display,
IdTokenHint = request.IdTokenHint,
LoginHint = request.LoginHint,
MaxAge = request.MaxAge,
Nonce = request.Nonce,
Prompt = request.Prompt,
RedirectUrl = request.RedirectUri,
ResponseMode = request.ResponseMode == null ? Core.Parameters.ResponseMode.None : (Core.Parameters.ResponseMode)request.ResponseMode,
ResponseType = request.ResponseType,
Scope = request.Scope,
State = request.State,
UiLocales = request.UiLocales,
OriginUrl = request.OriginUrl,
SessionId = request.SessionId,
AmrValues = string.IsNullOrWhiteSpace(request.AmrValues) ? new string[0] : request.AmrValues.Split(' ')
};
if (!string.IsNullOrWhiteSpace(request.ProcessId))
{
result.ProcessId = request.ProcessId;
}
if (!string.IsNullOrWhiteSpace(request.Claims))
{
var claimsParameter = new ClaimsParameter();
result.Claims = claimsParameter;
var obj = JObject.Parse(request.Claims);
var idToken = obj.GetValue(Core.Constants.StandardClaimParameterNames.IdTokenName);
var userInfo = obj.GetValue(Core.Constants.StandardClaimParameterNames.UserInfoName);
if (idToken != null)
{
claimsParameter.IdToken = new List <ClaimParameter>();
FillInClaimsParameter(idToken, claimsParameter.IdToken);
}
if (userInfo != null)
{
claimsParameter.UserInfo = new List <ClaimParameter>();
FillInClaimsParameter(userInfo, claimsParameter.UserInfo);
}
result.Claims = claimsParameter;
}
if (!string.IsNullOrWhiteSpace(request.CodeChallenge) && request.CodeChallengeMethod != null)
{
result.CodeChallenge = request.CodeChallenge;
result.CodeChallengeMethod = (Core.Common.Models.CodeChallengeMethods)request.CodeChallengeMethod;
}
return(result);
}
public void When_Trying_To_Retrieve_Standard_Claim_Names_From_EmptyList_Then_Empty_List_Is_Returned()
{
var claimsParameter = new ClaimsParameter();
var claimNames = claimsParameter.GetClaimNames();
Assert.Empty(claimNames);
}
public void When_Trying_To_Retrieve_Standard_Claim_Names_From_EmptyList_Then_Empty_List_Is_Returned()
{
// ARRANGE
var claimsParameter = new ClaimsParameter();
// ACT
var claimNames = claimsParameter.GetClaimNames();
// ASSERT
Assert.NotNull(claimNames);
Assert.False(claimNames.Any());
}
public void UserInfoShouldSet()
{
var claims = new ClaimsDictionary
{
["test"] = ClaimsValue.Required(),
["test2"] = ClaimsValue.WithValue(false, "1000"),
};
var parameter = new ClaimsParameter();
parameter.UserInfo = claims;
Assert.AreEqual(claims, parameter.UserInfo);
}
public async Task RequestUserInfoReturnsErrorWhenNoUserInfoUrl()
{
var claims = new ClaimsParameter();
_discoveryResponse.OperatorUrls.UserInfoUrl = null;
var result = await _mobileConnect.RequestUserInfoAsync(_request, _discoveryResponse, "zaqwsxcderfvbgtyhnmjukilop", new MobileConnectRequestOptions());
Assert.IsNull(result.IdentityResponse);
Assert.IsNotNull(result.ErrorCode);
Assert.IsNotNull(result.ErrorMessage);
Assert.AreEqual(MobileConnectResponseType.Error, result.ResponseType);
}
/// <summary>
/// Gets all the standard claim names from the ClaimsParameter
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
public static List <string> GetClaimNames(this ClaimsParameter parameter)
{
var result = new List <string>();
var fillInClaims = new Action <List <ClaimParameter>, List <string> >((cps, r) =>
{
if (cps != null &&
cps.Any())
{
r.AddRange(cps
.Where(cl => IsStandardClaim(cl.Name))
.Select(s => s.Name));
}
});
fillInClaims(parameter.IdToken, result);
fillInClaims(parameter.UserInfo, result);
return(result);
}
public void StartAuthenticationWithClaimsShouldEncodeAndIncludeClaims()
{
var claims = new ClaimsParameter();
claims.IdToken.AddRequired("test1");
claims.UserInfo.AddWithValue("test2", false, "testvalue");
var options = new AuthenticationOptions {
Claims = claims
};
var expectedClaims = JsonConvert.SerializeObject(claims, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
var result = _authentication.StartAuthentication(_config.ClientId, AUTHORIZE_URL, REDIRECT_URL, "state", "nonce", null, _defaultVersions, options);
var actualClaims = HttpUtils.ExtractQueryValue(result.Url, "claims");
Assert.IsNotEmpty(actualClaims);
Assert.AreEqual(expectedClaims, actualClaims);
}
public void When_Passing_Standard_Claims_In_UserInfo_And_Trying_To_Retrieve_The_Names_Then_Names_Are_Returned()
{
const string notStandardClaimName = "not_standard";
var claimsParameter = new ClaimsParameter
{
UserInfo = new[]
{
new ClaimParameter {
Name = OpenIdClaimTypes.Subject
},
new ClaimParameter {
Name = notStandardClaimName
}
}
};
var claimNames = claimsParameter.GetClaimNames();
Assert.Contains(OpenIdClaimTypes.Subject, claimNames);
Assert.DoesNotContain(notStandardClaimName, claimNames);
}
public static List <string> GetAllClaimsNames(this ClaimsParameter parameter)
{
var result = new List <string>();
if (!parameter.IsAnyUserInfoClaimParameter() &&
!parameter.IsAnyUserInfoClaimParameter())
{
return(result);
}
if (!parameter.IsAnyUserInfoClaimParameter())
{
result.AddRange(parameter.UserInfo.Select(s => s.Name));
}
if (!parameter.IsAnyIdentityTokenClaimParameter())
{
result.AddRange(parameter.IdToken.Select(s => s.Name));
}
return(result);
}
/// <summary>
/// Returns a boolean which indicates if the ClaimsParameter contains at least one identity-token claim parameter
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
public static bool IsAnyIdentityTokenClaimParameter(this ClaimsParameter parameter)
{
return(parameter != null &&
parameter.IdToken != null &&
parameter.IdToken.Any());
}
/// <summary>
/// Return a boolean which indicates if the ClaimsParameter contains at least one user-info claim parameter
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
public static bool IsAnyUserInfoClaimParameter(this ClaimsParameter parameter)
{
return(parameter != null &&
parameter.UserInfo != null &&
parameter.UserInfo.Any());
}
public static AuthorizationParameter ToParameter(this AuthorizationRequest request)
{
var result = new AuthorizationParameter
{
AcrValues = request.acr_values,
ClientId = request.client_id,
IdTokenHint = request.id_token_hint,
LoginHint = request.login_hint,
MaxAge = request.max_age,
Nonce = request.nonce,
Prompt = request.prompt,
RedirectUrl = request.redirect_uri,
ResponseMode = request.response_mode ?? ResponseModes.None,
ResponseType = request.response_type,
Scope = request.scope,
State = request.state,
UiLocales = request.ui_locales,
OriginUrl = request.origin_url,
SessionId = request.session_id,
AmrValues = string.IsNullOrWhiteSpace(request.amr_values) ? Array.Empty <string>() : request.amr_values.Split(' ')
};
if (!string.IsNullOrWhiteSpace(request.aggregate_id))
{
result = result with {
ProcessId = request.aggregate_id
};
}
if (!string.IsNullOrWhiteSpace(request.claims))
{
result = result with {
Claims = new ClaimsParameter()
};
var obj = JObject.Parse(request.claims);
var idToken = obj.GetValue(CoreConstants.StandardClaimParameterNames.IdTokenName);
var userInfo = obj.GetValue(CoreConstants.StandardClaimParameterNames.UserInfoName);
if (idToken != null)
{
result = result with
{
Claims = result.Claims with
{
IdToken = FillInClaimsParameter(idToken, result.Claims.IdToken)
}
};
}
if (userInfo != null)
{
result = result with
{
Claims = result.Claims with
{
UserInfo = FillInClaimsParameter(userInfo, result.Claims.UserInfo)
}
};
}
}
if (!string.IsNullOrWhiteSpace(request.code_challenge) && request.code_challenge_method != null)
{
result = result with
{
CodeChallenge = request.code_challenge,
CodeChallengeMethod = request.code_challenge_method
};
}
return(result);
}
