public virtual void ReadXml(XmlDictionaryReader reader)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
reader.MoveToContent();
if (reader.IsStartElement(XD.XmlSignatureDictionary.KeyInfo.Value, XD.XmlSignatureDictionary.Namespace.Value))
{
// <KeyInfo>
reader.ReadStartElement();
while (reader.IsStartElement())
{
// <RetrievalMethod>
if (reader.IsStartElement(XmlSignatureConstants.Elements.RetrievalMethod, XD.XmlSignatureDictionary.Namespace.Value))
{
string method = reader.GetAttribute(XD.XmlSignatureDictionary.URI.Value);
if (!string.IsNullOrEmpty(method))
{
_retrieval = method;
}
reader.Skip();
}
// check if internal serializer can handle clause
else if (_keyInfoSerializer.CanReadKeyIdentifierClause(reader))
{
_ski.Add(_keyInfoSerializer.ReadKeyIdentifierClause(reader));
}
// trace we skipped over an element
else if (reader.IsStartElement())
{
string xml = reader.ReadOuterXml();
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceString(System.Diagnostics.TraceEventType.Warning, SR.GetString(SR.ID8023, reader.Name, reader.NamespaceURI, xml));
}
}
reader.MoveToContent();
}
reader.MoveToContent();
reader.ReadEndElement();
}
}
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 CanReadKeyIdentifierClauseCore(XmlReader reader)
{
return(serializer.CanReadKeyIdentifierClause(reader));
}