void ReadTokenContent()
{
switch (reader.NamespaceURI)
{
case Constants.WstNamespace:
switch (reader.LocalName)
{
case "RequestedSecurityToken":
res.RequestedSecurityToken = (SecurityContextSecurityToken)ReadToken();
return;
case "RequestedProofToken":
#if true // FIXME: we can't handle it right now
string ens = EncryptedXml.XmlEncNamespaceUrl;
reader.Read();
reader.ReadStartElement("EncryptedKey", ens);
string alg = reader.GetAttribute("Algorithm");
bool isEmpty = reader.IsEmptyElement;
reader.ReadStartElement("EncryptionMethod", ens);
if (alg != negotiation_type)
{
throw new XmlException(String.Format("EncryptionMethod '{0}' is not supported in RequestedProofToken.", alg));
}
if (!isEmpty)
{
reader.ReadEndElement();
}
reader.ReadStartElement("CipherData", ens);
reader.ReadStartElement("CipherValue", ens);
byte [] pt = reader.ReadContentAsBase64();
res.RequestedProofToken = pt;
reader.ReadEndElement();
reader.ReadEndElement();
reader.ReadEndElement(); // EncryptedKey
reader.ReadEndElement(); // RPT
#else
reader.Read();
reader.MoveToContent();
if (serializer.CanReadToken(reader))
{
res.RequestedProofToken = serializer.ReadToken(reader, resolver);
}
else
{
res.RequestedProofToken = serializer.ReadKeyIdentifierClause(reader);
}
reader.ReadEndElement();
#endif
return;
case "BinaryExchange":
ReadBinaryExchange();
return;
case "TokenType":
res.TokenType = reader.ReadElementContentAsString();
return;
case "Lifetime":
ReadLifetime();
return;
case "KeySize":
res.KeySize = reader.ReadElementContentAsInt();
return;
case "RequestedAttachedReference":
res.RequestedAttachedReference = ReadTokenReference();
return;
case "RequestedUnattachedReference":
res.RequestedUnattachedReference = ReadTokenReference();
return;
case "Authenticator":
ReadAuthenticator();
return;
}
break;
}
throw new XmlException(String.Format("Unexpected RequestSecurityTokenResponse content element. Name is {0} and namespace URI is {1} {2}", reader.Name, reader.NamespaceURI, LineInfo()));
}
object ReadContent(XmlReader reader)
{
reader.MoveToContent();
if (reader.NodeType != XmlNodeType.Element)
{
throw new XmlException(String.Format("Node type {0} is not expected as a WS-Security message header content.", reader.NodeType));
}
switch (reader.NamespaceURI)
{
case Constants.WsuNamespace:
switch (reader.LocalName)
{
case "Timestamp":
return(ReadTimestamp(reader));
}
break;
//case Constants.WstNamespace:
case Constants.Wss11Namespace:
if (reader.LocalName == "SignatureConfirmation")
{
return(ReadSignatureConfirmation(reader, doc));
}
break;
case SignedXml.XmlDsigNamespaceUrl:
switch (reader.LocalName)
{
case "Signature":
WSSignedXml sxml = new WSSignedXml(doc);
sxml.Signature.LoadXml((XmlElement)doc.ReadNode(reader));
UpdateSignatureKeyInfo(sxml.Signature, doc, serializer);
return(sxml);
}
break;
case EncryptedXml.XmlEncNamespaceUrl:
switch (reader.LocalName)
{
case "EncryptedData":
XmlElement el = (XmlElement)doc.ReadNode(reader);
return(CreateEncryptedData(el));
case "ReferenceList":
ReferenceList rl = new ReferenceList();
reader.Read();
for (reader.MoveToContent();
reader.NodeType != XmlNodeType.EndElement;
reader.MoveToContent())
{
switch (reader.LocalName)
{
case "DataReference":
DataReference dref = new DataReference();
dref.LoadXml((XmlElement)doc.ReadNode(reader));
rl.Add(dref);
continue;
case "KeyReference":
KeyReference kref = new KeyReference();
kref.LoadXml((XmlElement)doc.ReadNode(reader));
rl.Add(kref);
continue;
}
throw new XmlException(String.Format("Unexpected {2} node '{0}' in namespace '{1}' in ReferenceList.", reader.Name, reader.NamespaceURI, reader.NodeType));
}
reader.ReadEndElement();
return(rl);
}
break;
}
// SecurityTokenReference will be handled here.
// This order (Token->KeyIdentifierClause) is
// important because WrappedKey could be read
// in both context (but must be a token here).
if (serializer.CanReadToken(reader))
{
return(serializer.ReadToken(reader, resolver));
}
else if (serializer.CanReadKeyIdentifierClause(reader))
{
return(serializer.ReadKeyIdentifierClause(reader));
}
else
{
throw new XmlException(String.Format("Unexpected element '{0}' in namespace '{1}' as a WS-Security message header content.", reader.Name, reader.NamespaceURI));
}
}
protected override bool CanReadTokenCore(XmlReader reader)
{
return(serializer.CanReadToken(reader));
}