public WsTrustRequestBodyWriter(WsTrustVersion version, WsTrustSerializer serializer, WsTrustRequest request)
: base(true)
{
_version = version;
_request = request;
_serializer = serializer;
}
public WsTrustEndpoint(Uri uri, WsTrustVersion version, ITimeService timeService = null, IGuidFactory guidFactory = null)
{
Uri = uri;
Version = version;
_timeService = timeService ?? new TimeService();
_guidFactory = guidFactory ?? new GuidFactory();
}
private WsTrustEndpoint CreateWsTrustEndpoint(WsTrustVersion version)
{
var wsTrustEndpoint = new WsTrustEndpoint(
version,
new Uri(EndpointUriString),
_timeAndGuidServiceHelper.GuidService,
_timeAndGuidServiceHelper.TimeService);
return(wsTrustEndpoint);
}
public WsTrustEndpoint(
WsTrustVersion version,
Uri uri,
IGuidService guidService,
ITimeService timeService)
{
Version = version;
Uri = uri;
_guidService = guidService;
_timeService = timeService;
}
public WsTrustChannel(WsTrustVersion version, IWsTrustContract contract, WsTrustSerializer serializer)
: base(contract as IChannel)
{
// TODO: add null guards
_version = version;
_constants = GetConstants(version);
// TODO: get message version from binding
_messageVersion = MessageVersion.Default;
_contract = contract;
_serializer = serializer;
}
private string GetWsTrustVersionString(WsTrustVersion version)
{
if (version == WsTrustVersion.Trust13)
{
return(nameof(WsTrustVersion.Trust13));
}
if (version == WsTrustVersion.Trust14)
{
return(nameof(WsTrustVersion.Trust14));
}
if (version == WsTrustVersion.TrustFeb2005)
{
return(nameof(WsTrustVersion.TrustFeb2005));
}
return("unknown");
}
private static WsTrustConstants GetConstants(WsTrustVersion version)
{
if (version == WsTrustVersion.TrustFeb2005)
{
return(WsTrustConstants.TrustFeb2005);
}
if (version == WsTrustVersion.Trust13)
{
return(WsTrustConstants.Trust13);
}
if (version == WsTrustVersion.Trust14)
{
return(WsTrustConstants.Trust14);
}
throw new ArgumentException("Invalid WS-Trust version", nameof(version));
}
protected virtual WsTrustConstants GetWsTrustConstants(WsTrustVersion version)
{
if (version == WsTrustVersion.TrustFeb2005)
{
return(WsTrustConstants.TrustFeb2005);
}
if (version == WsTrustVersion.Trust13)
{
return(WsTrustConstants.Trust13);
}
if (version == WsTrustVersion.Trust14)
{
return(WsTrustConstants.Trust14);
}
throw new NotSupportedException("Trust version not supported.");
}
private static void AddPolicy(IDictionary <string, MexPolicy> policies, XElement policy, UserAuthType policyAuthType, bool isWsTrust2005)
{
XElement binding = policy.Descendants(XmlNamespace.Sp + "TransportBinding").FirstOrDefault()
?? policy.Descendants(XmlNamespace.Sp2005 + "TransportBinding").FirstOrDefault();
if (binding != null)
{
XAttribute id = policy.Attribute(XmlNamespace.Wsu + "Id");
WsTrustVersion version = WsTrustVersion.WsTrust13;
if (isWsTrust2005)
{
version = WsTrustVersion.WsTrust2005;
}
if (id != null)
{
policies.Add("#" + id.Value, new MexPolicy {
Id = id.Value, AuthType = policyAuthType, Version = version
});
}
}
}
public static WsTrustResponse CreateFromResponse(Stream responseStream, WsTrustVersion version)
{
XDocument responseDocument = ReadDocumentFromResponse(responseStream);
return(CreateFromResponseDocument(responseDocument, version));
}
public WsTrustResponseObjectSerializer(WsTrustVersion version, WsTrustSerializer inner)
{
_version = version;
_inner = inner;
}
internal static WsTrustResponse CreateFromResponseDocument(XDocument responseDocument, WsTrustVersion version)
{
Dictionary <string, string> tokenResponseDictionary = new Dictionary <string, string>();
try
{
XNamespace t = XmlNamespace.Trust;
if (version == WsTrustVersion.WsTrust2005)
{
t = XmlNamespace.Trust2005;
}
bool parseResponse = true;
if (version == WsTrustVersion.WsTrust13)
{
XElement requestSecurityTokenResponseCollection =
responseDocument.Descendants(t + "RequestSecurityTokenResponseCollection").FirstOrDefault();
if (requestSecurityTokenResponseCollection == null)
{
parseResponse = false;
}
}
if (parseResponse)
{
IEnumerable <XElement> tokenResponses =
responseDocument.Descendants(t + "RequestSecurityTokenResponse");
foreach (var tokenResponse in tokenResponses)
{
XElement tokenTypeElement = tokenResponse.Elements(t + "TokenType").FirstOrDefault();
if (tokenTypeElement == null)
{
continue;
}
XElement requestedSecurityToken =
tokenResponse.Elements(t + "RequestedSecurityToken").FirstOrDefault();
if (requestedSecurityToken == null)
{
continue;
}
// TODO #123622: We need to disable formatting due to a potential service bug. Remove the ToString argument when problem is fixed.
tokenResponseDictionary.Add(tokenTypeElement.Value,
requestedSecurityToken.FirstNode.ToString(SaveOptions.DisableFormatting));
}
}
}
catch (XmlException ex)
{
throw new AdalException(AdalError.ParsingWsTrustResponseFailed, ex);
}
if (tokenResponseDictionary.Count == 0)
{
throw new AdalException(AdalError.ParsingWsTrustResponseFailed);
}
string tokenType = tokenResponseDictionary.ContainsKey(Saml1Assertion) ? Saml1Assertion : tokenResponseDictionary.Keys.First();
WsTrustResponse wsTrustResponse = new WsTrustResponse
{
TokenType = tokenType,
Token = tokenResponseDictionary[tokenType]
};
return(wsTrustResponse);
}
protected virtual async ValueTask <Message> ProcessCoreAsync(Message requestMessage, string requestAction, string responseAction, WsTrustVersion version)
{
var constants = GetWsTrustConstants(version);
var trace = new WsTrustMessageInformation
{
RequestAction = requestAction,
ResponseAction = responseAction,
WsTrustVersion = version,
TrustNamespace = constants.Namespace
};
WsTrustLogMessages.WsTrustMessage(_logger, trace, null);
var context = await CreateDispatchContextAsync(requestMessage, requestAction, responseAction, constants);
await ValidateDispatchContextAsync(context);
await DispatchRequestAsync(context, constants);
var serializer = _serializerFactory.Create();
_logger.LogInformation($"Serializing response for '{responseAction}'.");
var response = Message.CreateMessage(context.MessageVersion, context.ResponseAction, context.ResponseMessage, new WsTrustResponseObjectSerializer(version, serializer));
return(response);
}
internal static WsTrustResponse CreateFromResponseDocument(XDocument responseDocument, WsTrustVersion version)
{
Dictionary<string, string> tokenResponseDictionary = new Dictionary<string, string>();
try
{
XNamespace t = XmlNamespace.Trust;
if (version == WsTrustVersion.WsTrust2005)
{
t = XmlNamespace.Trust2005;
}
bool parseResponse = true;
if (version == WsTrustVersion.WsTrust13)
{
XElement requestSecurityTokenResponseCollection =
responseDocument.Descendants(t + "RequestSecurityTokenResponseCollection").FirstOrDefault();
if (requestSecurityTokenResponseCollection == null)
{
parseResponse = false;
}
}
if (parseResponse)
{
IEnumerable<XElement> tokenResponses =
responseDocument.Descendants(t + "RequestSecurityTokenResponse");
foreach (var tokenResponse in tokenResponses)
{
XElement tokenTypeElement = tokenResponse.Elements(t + "TokenType").FirstOrDefault();
if (tokenTypeElement == null)
{
continue;
}
XElement requestedSecurityToken =
tokenResponse.Elements(t + "RequestedSecurityToken").FirstOrDefault();
if (requestedSecurityToken == null)
{
continue;
}
// TODO #123622: We need to disable formatting due to a potential service bug. Remove the ToString argument when problem is fixed.
tokenResponseDictionary.Add(tokenTypeElement.Value,
requestedSecurityToken.FirstNode.ToString(SaveOptions.DisableFormatting));
}
}
}
catch (XmlException ex)
{
PlatformPlugin.Logger.Error(null, ex);
throw new MsalException(MsalError.ParsingWsTrustResponseFailed, ex);
}
if (tokenResponseDictionary.Count == 0)
{
throw new MsalException(MsalError.ParsingWsTrustResponseFailed);
}
string tokenType = tokenResponseDictionary.ContainsKey(Saml1Assertion) ? Saml1Assertion : tokenResponseDictionary.Keys.First();
WsTrustResponse wsTrustResponse = new WsTrustResponse
{
TokenType = tokenType,
Token = tokenResponseDictionary[tokenType]
};
return wsTrustResponse;
}
public static WsTrustResponse CreateFromResponse(string response, WsTrustVersion version)
{
XDocument responseDocument = XDocument.Parse(response, LoadOptions.PreserveWhitespace); // Could throw XmlException
return(CreateFromResponseDocument(responseDocument, version));
}
internal static WsTrustResponse CreateFromResponseDocument(XDocument responseDocument, WsTrustVersion version)
{
Dictionary <string, string> tokenResponseDictionary = new Dictionary <string, string>();
XNamespace t = XmlNamespace.Trust;
if (version == WsTrustVersion.WsTrust2005)
{
t = XmlNamespace.Trust2005;
}
bool parseResponse = true;
if (version == WsTrustVersion.WsTrust13)
{
XElement requestSecurityTokenResponseCollection =
responseDocument.Descendants(t + "RequestSecurityTokenResponseCollection").FirstOrDefault();
if (requestSecurityTokenResponseCollection == null)
{
parseResponse = false;
}
}
if (!parseResponse)
{
return(null);
}
IEnumerable <XElement> tokenResponses =
responseDocument.Descendants(t + "RequestSecurityTokenResponse");
foreach (var tokenResponse in tokenResponses)
{
XElement tokenTypeElement = tokenResponse.Elements(t + "TokenType").FirstOrDefault();
if (tokenTypeElement == null)
{
continue;
}
XElement requestedSecurityToken =
tokenResponse.Elements(t + "RequestedSecurityToken").FirstOrDefault();
if (requestedSecurityToken == null)
{
continue;
}
var token = new System.Text.StringBuilder();
foreach (var node in requestedSecurityToken.Nodes())
{
// Since we moved from XDocument.Load(..., LoadOptions.None) to Load(..., LoadOptions.PreserveWhitespace),
// requestedSecurityToken can contain multiple nodes, and the first node is possibly just whitespaces e.g. "\n ",
// so we concatenate all the sub-nodes to include everything
token.Append(node.ToString(SaveOptions.DisableFormatting));
}
tokenResponseDictionary.Add(tokenTypeElement.Value, token.ToString());
}
if (tokenResponseDictionary.Count == 0)
{
return(null);
}
string tokenType = tokenResponseDictionary.ContainsKey(Saml1Assertion)
? Saml1Assertion
: tokenResponseDictionary.Keys.First();
WsTrustResponse wsTrustResponse = new WsTrustResponse
{
TokenType = tokenType,
Token = tokenResponseDictionary[tokenType]
};
return(wsTrustResponse);
}
public static WsTrustResponse CreateFromResponse(Stream responseStream, WsTrustVersion version)
{
XDocument responseDocument = ReadDocumentFromResponse(responseStream);
return CreateFromResponseDocument(responseDocument, version);
}
