public Dictionary <string, string> GetPreviousRequestRecord(CallState callState)
{
Dictionary <string, string> parameters;
if (callState != null)
{
parameters = GetClientMetricsParameters();
}
else
{
parameters = new Dictionary <string, string>();
}
return(parameters);
}
public void EndClientMetricsRecord(string endpoint, CallState callState)
{
if (callState != null && metricsTimer != null)
{
metricsTimer.Stop();
lastResponseTime = metricsTimer.ElapsedMilliseconds;
lastCorrelationId = callState.CorrelationId;
lastEndpoint = endpoint;
lock (PendingClientMetricsLock)
{
if (pendingClientMetrics == null)
{
pendingClientMetrics = this;
}
}
}
}
public static Dictionary <string, string> ParseKeyValueList(string input, char delimiter, bool urlDecode,
bool lowercaseKeys,
CallState callState)
{
var response = new Dictionary <string, string>();
List <string> queryPairs = SplitWithQuotes(input, delimiter);
foreach (string queryPair in queryPairs)
{
List <string> pair = SplitWithQuotes(queryPair, '=');
if (pair.Count == 2 && !string.IsNullOrWhiteSpace(pair[0]) && !string.IsNullOrWhiteSpace(pair[1]))
{
string key = pair[0];
string value = pair[1];
// Url decoding is needed for parsing OAuth response, but not for parsing WWW-Authenticate header in 401 challenge
if (urlDecode)
{
key = UrlDecode(key);
value = UrlDecode(value);
}
if (lowercaseKeys)
{
key = key.Trim().ToLower();
}
value = value.Trim().Trim(new[] { '\"' }).Trim();
if (response.ContainsKey(key) && callState != null)
{
PlatformPlugin.Logger.Warning(callState,
string.Format(CultureInfo.InvariantCulture,
"Key/value pair list contains redundant key '{0}'.", key));
}
response[key] = value;
}
}
return(response);
}
public async Task UpdateFromTemplateAsync(CallState callState)
{
if (!this.updatedFromTemplate)
{
var authorityUri = new Uri(this.Authority);
string host = authorityUri.Authority;
string path = authorityUri.AbsolutePath.Substring(1);
string tenant = path.Substring(0, path.IndexOf("/", StringComparison.Ordinal));
AuthenticatorTemplate matchingTemplate = await AuthenticatorTemplateList.FindMatchingItemAsync(this.ValidateAuthority, host, tenant, callState).ConfigureAwait(false);
this.AuthorizationUri = matchingTemplate.AuthorizeEndpoint.Replace("{tenant}", tenant);
this.DeviceCodeUri = matchingTemplate.DeviceCodeEndpoint.Replace("{tenant}", tenant);
this.TokenUri = matchingTemplate.TokenEndpoint.Replace("{tenant}", tenant);
this.UserRealmUri = CanonicalizeUri(matchingTemplate.UserRealmEndpoint);
this.IsTenantless = IsTenantLess(this.Authority);
this.SelfSignedJwtAudience = matchingTemplate.Issuer.Replace("{tenant}", tenant);
this.updatedFromTemplate = true;
}
}
public static string ReadErrorResponse(XDocument responseDocument, CallState callState)
{
string errorMessage = null;
try
{
XElement body = responseDocument.Descendants(XmlNamespace.SoapEnvelope + "Body").FirstOrDefault();
if (body != null)
{
XElement fault = body.Elements(XmlNamespace.SoapEnvelope + "Fault").FirstOrDefault();
if (fault != null)
{
XElement reason = fault.Elements(XmlNamespace.SoapEnvelope + "Reason").FirstOrDefault();
if (reason != null)
{
XElement text = reason.Elements(XmlNamespace.SoapEnvelope + "Text").FirstOrDefault();
if (text != null)
{
using (var reader = text.CreateReader())
{
reader.MoveToContent();
errorMessage = reader.ReadInnerXml();
}
}
}
}
}
}
catch (XmlException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException(MsalError.ParsingWsTrustResponseFailed, ex);
}
return(errorMessage);
}
public abstract void Error(CallState callState, Exception ex,
[System.Runtime.CompilerServices.CallerFilePath] string callerFilePath = "");
public abstract void Error(CallState callState, string errorMessage,
[System.Runtime.CompilerServices.CallerFilePath] string callerFilePath = "");
public abstract void Warning(CallState callState, string message,
[System.Runtime.CompilerServices.CallerFilePath] string callerFilePath = "");
public static async Task <WsTrustAddress> FetchWsTrustAddressFromMexAsync(string federationMetadataUrl, UserAuthType userAuthType, CallState callState)
{
XDocument mexDocument = await FetchMexAsync(federationMetadataUrl, callState).ConfigureAwait(false);
return(ExtractWsTrustAddressFromMex(mexDocument, userAuthType, callState));
}
public virtual string GetRedirectUriAsString(Uri redirectUri, CallState callState)
{
return(redirectUri.OriginalString);
}
public HttpClientWrapper(string uri, CallState callState)
{
this.uri = uri;
this.Headers = new Dictionary <string, string>();
this.CallState = callState;
}
internal static string PrepareLogMessage(CallState callState, string classOrComponent, string message)
{
string correlationId = (callState != null) ? callState.CorrelationId.ToString() : string.Empty;
return(string.Format(CultureInfo.CurrentCulture, "{0}: {1} - {2}: {3}", DateTime.UtcNow, correlationId, classOrComponent, message));
}
internal abstract void Information(CallState callState, string message, [System.Runtime.CompilerServices.CallerFilePath] string callerFilePath = "");
public static Dictionary <string, string> ParseKeyValueList(string input, char delimiter, bool urlDecode,
CallState callState)
{
return(ParseKeyValueList(input, delimiter, urlDecode, true, callState));
}
public static async Task <WsTrustResponse> SendRequestAsync(WsTrustAddress wsTrustAddress, UserCredential credential, CallState callState)
{
HttpClientWrapper request = new HttpClientWrapper(wsTrustAddress.Uri.AbsoluteUri, callState);
request.ContentType = "application/soap+xml";
if (credential.UserAuthType == UserAuthType.IntegratedAuth)
{
SetKerberosOption(request);
}
StringBuilder messageBuilder = BuildMessage(DefaultAppliesTo, wsTrustAddress, credential);
WsTrustResponse wstResponse;
try
{
request.BodyParameters = new StringRequestParameters(messageBuilder);
IHttpWebResponse response = await request.GetResponseAsync().ConfigureAwait(false);
wstResponse = WsTrustResponse.CreateFromResponse(response.ResponseStream, wsTrustAddress.Version);
}
catch (WebException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
string errorMessage;
try
{
XDocument responseDocument = WsTrustResponse.ReadDocumentFromResponse(ex.Response.GetResponseStream());
errorMessage = WsTrustResponse.ReadErrorResponse(responseDocument, callState);
}
catch (MsalException)
{
errorMessage = "See inner exception for detail.";
}
throw new MsalServiceException(
MsalError.FederatedServiceReturnedError,
string.Format(MsalErrorMessage.FederatedServiceReturnedErrorTemplate, wsTrustAddress.Uri, errorMessage),
null,
ex);
}
return(wstResponse);
}
internal static async Task <XDocument> FetchMexAsync(string federationMetadataUrl, CallState callState)
{
XDocument mexDocument;
try
{
HttpClientWrapper request = new HttpClientWrapper(federationMetadataUrl, callState);
using (var response = await request.GetResponseAsync().ConfigureAwait(false))
{
mexDocument = XDocument.Load(response.ResponseStream, LoadOptions.None);
}
}
catch (WebException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalServiceException(MsalError.AccessingWsMetadataExchangeFailed, ex);
}
catch (XmlException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException(MsalError.ParsingWsMetadataExchangeFailed, ex);
}
return(mexDocument);
}
public MsalHttpClient(string uri, CallState callState)
{
this.Client = new HttpClientWrapper(CheckForExtraQueryParameter(uri), callState);
this.CallState = callState;
}
public async Task <AuthenticatorTemplate> FindMatchingItemAsync(bool validateAuthority, string host, string tenant, CallState callState)
{
AuthenticatorTemplate matchingAuthenticatorTemplate = null;
if (validateAuthority)
{
matchingAuthenticatorTemplate = this.FirstOrDefault(a => string.Compare(host, a.Host, StringComparison.OrdinalIgnoreCase) == 0);
if (matchingAuthenticatorTemplate == null)
{
// We only check with the first trusted authority (login.windows.net) for instance discovery
await this.First().VerifyAnotherHostByInstanceDiscoveryAsync(host, tenant, callState).ConfigureAwait(false);
}
}
return(matchingAuthenticatorTemplate ?? AuthenticatorTemplate.CreateFromHost(host));
}
public async virtual Task <bool> IsUserLocalAsync(CallState callState)
{
return(await Task.Factory.StartNew(() => false).ConfigureAwait(false));
}
internal static async Task <UserRealmDiscoveryResponse> CreateByDiscoveryAsync(string userRealmUri, string userName, CallState callState)
{
string userRealmEndpoint = userRealmUri;
userRealmEndpoint += (userName + "?api-version=1.0");
PlatformPlugin.Logger.Information(callState, string.Format("Sending user realm discovery request to '{0}'", userRealmEndpoint));
var client = new MsalHttpClient(userRealmEndpoint, callState)
{
Client = { Accept = "application/json" }
};
return(await client.GetResponseAsync <UserRealmDiscoveryResponse>(ClientMetricsEndpointType.UserRealmDiscovery).ConfigureAwait(false));
}
public async Task VerifyAnotherHostByInstanceDiscoveryAsync(string host, string tenant, CallState callState)
{
string instanceDiscoveryEndpoint = this.InstanceDiscoveryEndpoint;
instanceDiscoveryEndpoint += ("?api-version=1.0&authorization_endpoint=" + AuthorizeEndpointTemplate);
instanceDiscoveryEndpoint = instanceDiscoveryEndpoint.Replace("{host}", host);
instanceDiscoveryEndpoint = instanceDiscoveryEndpoint.Replace("{tenant}", tenant);
try
{
var client = new MsalHttpClient(instanceDiscoveryEndpoint, callState);
InstanceDiscoveryResponse discoveryResponse = await client.GetResponseAsync <InstanceDiscoveryResponse>(ClientMetricsEndpointType.InstanceDiscovery).ConfigureAwait(false);
if (discoveryResponse.TenantDiscoveryEndpoint == null)
{
throw new MsalException(MsalError.AuthorityNotInValidList);
}
}
catch (MsalServiceException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException((ex.ErrorCode == "invalid_instance") ? MsalError.AuthorityNotInValidList : MsalError.AuthorityValidationFailed, ex);
}
}
internal static WsTrustAddress ExtractWsTrustAddressFromMex(XDocument mexDocument, UserAuthType userAuthType, CallState callState)
{
WsTrustAddress address = null;
MexPolicy policy = null;
try
{
Dictionary <string, MexPolicy> policies = ReadPolicies(mexDocument);
Dictionary <string, MexPolicy> bindings = ReadPolicyBindings(mexDocument, policies);
SetPolicyEndpointAddresses(mexDocument, bindings);
Random random = new Random();
//try ws-trust 1.3 first
policy = policies.Values.Where(p => p.Url != null && p.AuthType == userAuthType && p.Version == WsTrustVersion.WsTrust13).OrderBy(p => random.Next()).FirstOrDefault() ??
policies.Values.Where(p => p.Url != null && p.AuthType == userAuthType).OrderBy(p => random.Next()).FirstOrDefault();
if (policy != null)
{
address = new WsTrustAddress();
address.Uri = policy.Url;
address.Version = policy.Version;
}
else if (userAuthType == UserAuthType.IntegratedAuth)
{
throw new MsalException(MsalError.IntegratedAuthFailed, new MsalException(MsalError.WsTrustEndpointNotFoundInMetadataDocument));
}
else
{
throw new MsalException(MsalError.WsTrustEndpointNotFoundInMetadataDocument);
}
}
catch (XmlException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException(MsalError.ParsingWsMetadataExchangeFailed, ex);
}
return(address);
}
