/// <summary>
/// Converts the specified <paramref name="exception"/> to an XML <see cref="Stream"/>.
/// </summary>
/// <param name="exception">The <see cref="Exception"/> to convert into an XML <see cref="Stream"/>.</param>
/// <param name="encoding">The preferred encoding to apply to the result.</param>
/// <param name="includeStackTrace">if set to <c>true</c> the stack trace of the exception (and possible user data) is included in the converted result.</param>
/// <returns>An XML <see cref="Stream"/> variant of the specified <paramref name="exception"/>.</returns>
public static Stream FromException(Exception exception, Encoding encoding, bool includeStackTrace)
{
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
MemoryStream tempOutput = null;
MemoryStream output;
try
{
tempOutput = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(tempOutput, XmlWriterUtility.CreateSettings(o => o.Encoding = encoding)))
{
WriteException(writer, exception, includeStackTrace);
writer.Flush();
tempOutput.Position = 0;
output = tempOutput;
tempOutput = null;
}
}
finally
{
if (tempOutput != null)
{
tempOutput.Dispose();
}
}
output.Position = 0;
return(output);
}
/// <summary>
/// Initializes a new instance of the <see cref="XmlFormatterOptions"/> class.
/// </summary>
/// <remarks>
/// The following table shows the initial property values for an instance of <see cref="XmlFormatterOptions"/>.
/// <list type="table">
/// <listheader>
/// <term>Property</term>
/// <description>Initial Value</description>
/// </listheader>
/// <item>
/// <term><see cref="FormatterOptions{TReader,TReaderOptions,TWriter,TWriterOptions,TConverter}.Converter"/></term>
/// <description><c>null</c></description>
/// </item>
/// <item>
/// <term><see cref="ReaderSettings"/></term>
/// <description><see cref="XmlReaderUtility.CreateSettings"/></description>
/// </item>
/// <item>
/// <term><see cref="WriterSettings"/></term>
/// <description><see cref="XmlWriterUtility.CreateSettings"/></description>
/// </item>
/// <item>
/// <term><see cref="RootName"/></term>
/// <description><c>null</c></description>
/// </item>
/// </list>
/// </remarks>
public XmlFormatterOptions()
{
Converter = null;
WriterSettings = XmlWriterUtility.CreateSettings();
ReaderSettings = XmlReaderUtility.CreateSettings();
RootName = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="XmlSerializerSettings"/> class.
/// </summary>
/// <remarks>
/// The following table shows the initial property values for an instance of <see cref="DefaultXmlConverter"/>.
/// <list type="table">
/// <listheader>
/// <term>Property</term>
/// <description>Initial Value</description>
/// </listheader>
/// <item>
/// <term><see cref="Reader"/></term>
/// <description><see cref="XmlReaderUtility.CreateSettings"/></description>
/// </item>
/// <item>
/// <term><see cref="Writer"/></term>
/// <description><see cref="XmlWriterUtility.CreateSettings"/></description>
/// </item>
/// <item>
/// <term><see cref="Converters"/></term>
/// <description><see cref="List{XmlConverter}"/></description>
/// </item>
/// <item>
/// <term><see cref="RootName"/></term>
/// <description><c>null</c></description>
/// </item>
/// </list>
/// </remarks>
public XmlSerializerSettings()
{
Writer = XmlWriterUtility.CreateSettings();
Reader = XmlReaderUtility.CreateSettings();
Converters = new List <XmlConverter>();
DefaultConverters?.Invoke(Converters);
}
/// <summary>
/// Revert the obfuscated XML document of <paramref name="value"/> to its original state by applying the mappable XML document of <paramref name="mapping"/>.
/// </summary>
/// <param name="value">The obfuscated <see cref="Stream"/> to revert.</param>
/// <param name="mapping">A <see cref="Stream"/> containing mappable values necessary to revert <paramref name="value"/> to its original state.</param>
/// <returns>
/// A <see cref="Stream"/> object where the obfuscated XML document has been reverted to its original XML document.
/// </returns>
public override Stream Revert(Stream value, Stream mapping)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (mapping == null)
{
throw new ArgumentNullException(nameof(mapping));
}
MemoryStream tempOutput = null;
try
{
XmlDocument document = XmlDocumentConverter.FromStream(mapping);
var mappingNode = document.DocumentElement;
XmlNode encryptedNode = mappingNode.GetElementsByTagName(MappingEncryptedElement).Item(0);
if (encryptedNode != null)
{
mappingNode.InnerXml = StringConverter.FromBytes(AdvancedEncryptionStandardUtility.Decrypt(Convert.FromBase64String(encryptedNode.InnerText), Key, InitializationVector), options =>
{
options.Encoding = Encoding;
options.Preamble = PreambleSequence.Remove;
});
}
tempOutput = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(tempOutput, XmlWriterUtility.CreateSettings(o => o.Encoding = Encoding)))
{
document.WriteTo(writer);
}
tempOutput.Position = 0;
mapping = tempOutput;
tempOutput = null;
}
finally
{
if (tempOutput != null)
{
tempOutput.Dispose();
}
}
return(base.Revert(value, mapping));
}
/// <summary>
/// Serializes the specified <paramref name="value"/> to a <see cref="Stream" />.
/// </summary>
/// <param name="value">The object to serialize to XML format.</param>
/// <param name="serializer">The object that will handle the serialization.</param>
/// <returns>A stream of the serialized object.</returns>
public static Stream SerializeObject(object value, XmlConverter serializer)
{
return(XmlWriterUtility.CreateXml(writer =>
{
serializer.WriteXml(writer, value);
}, settings =>
{
settings.Encoding = serializer.Options.WriterSettings.Encoding;
settings.OmitXmlDeclaration = serializer.Options.WriterSettings.OmitXmlDeclaration;
settings.CheckCharacters = serializer.Options.WriterSettings.CheckCharacters;
settings.CloseOutput = serializer.Options.WriterSettings.CloseOutput;
settings.ConformanceLevel = serializer.Options.WriterSettings.ConformanceLevel;
settings.Indent = serializer.Options.WriterSettings.Indent;
settings.IndentChars = serializer.Options.WriterSettings.IndentChars;
settings.NamespaceHandling = serializer.Options.WriterSettings.NamespaceHandling;
settings.NewLineChars = serializer.Options.WriterSettings.NewLineChars;
settings.NewLineHandling = serializer.Options.WriterSettings.NewLineHandling;
settings.NewLineOnAttributes = serializer.Options.WriterSettings.NewLineOnAttributes;
settings.WriteEndDocumentOnClose = serializer.Options.WriterSettings.WriteEndDocumentOnClose;
settings.Async = serializer.Options.WriterSettings.Async;
}));
}
/// <summary>
/// Serializes the specified <paramref name="value"/> to a <see cref="Stream" />.
/// </summary>
/// <param name="value">The object to serialize to XML format.</param>
/// <param name="objectType">The type of the object to serialize.</param>
/// <returns>A stream of the serialized object.</returns>
public Stream Serialize(object value, Type objectType)
{
return(XmlWriterUtility.CreateXml(writer =>
{
Serialize(writer, value, objectType);
}, settings =>
{
settings.Encoding = Settings.Writer.Encoding;
settings.OmitXmlDeclaration = Settings.Writer.OmitXmlDeclaration;
settings.CheckCharacters = Settings.Writer.CheckCharacters;
settings.CloseOutput = Settings.Writer.CloseOutput;
settings.ConformanceLevel = Settings.Writer.ConformanceLevel;
settings.Indent = Settings.Writer.Indent;
settings.IndentChars = Settings.Writer.IndentChars;
settings.NamespaceHandling = Settings.Writer.NamespaceHandling;
settings.NewLineChars = Settings.Writer.NewLineChars;
settings.NewLineHandling = Settings.Writer.NewLineHandling;
settings.NewLineOnAttributes = Settings.Writer.NewLineOnAttributes;
settings.WriteEndDocumentOnClose = Settings.Writer.WriteEndDocumentOnClose;
settings.Async = Settings.Writer.Async;
}));
}
/// <summary>
/// Creates and returns a mappable XML document of the original values and the obfuscated values.
/// </summary>
/// <returns>A mappable XML document of the original values and the obfuscated values.</returns>
public override Stream CreateMapping()
{
MemoryStream output;
MemoryStream tempOutput = null;
try
{
XmlDocument document = XmlDocumentConverter.FromStream(base.CreateMapping());
XmlNode mappingNode = document.DocumentElement;
string innerXmlOfMappingNode = mappingNode.InnerXml;
byte[] innerXmlOfMappingNodeBytes = ByteConverter.FromString(innerXmlOfMappingNode, options =>
{
options.Encoding = Encoding;
options.Preamble = PreambleSequence.Remove;
});
XmlElement encryptedNode = document.CreateElement(MappingEncryptedElement);
encryptedNode.InnerText = Convert.ToBase64String(AdvancedEncryptionStandardUtility.Encrypt(innerXmlOfMappingNodeBytes, Key, InitializationVector));
mappingNode.InnerXml = "";
mappingNode.AppendChild(encryptedNode);
tempOutput = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(tempOutput, XmlWriterUtility.CreateSettings(o => o.Encoding = Encoding)))
{
document.WriteTo(writer);
}
tempOutput.Position = 0;
output = tempOutput;
tempOutput = null;
}
finally
{
if (tempOutput != null)
{
tempOutput.Dispose();
}
}
return(output);
}
/// <summary>
/// Creates and returns a mappaple XML document of the original values and the obfuscated values.
/// </summary>
/// <returns>A mappaple XML document of the original values and the obfuscated values.</returns>
public override Stream CreateMapping()
{
MemoryStream output;
MemoryStream tempOutput = null;
try
{
tempOutput = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(tempOutput, XmlWriterUtility.CreateSettings(o => o.Encoding = Encoding)))
{
writer.WriteStartDocument();
writer.WriteComment(string.Format(CultureInfo.InvariantCulture, " Legend: {0}=Obfuscated, {1}=Value, {2}=mapsTo ", MappingRootElement, MappingValueElement, MappingMapsToAttribute));
writer.WriteStartElement(MappingRootElement);
foreach (KeyValuePair <string, ObfuscatorMapping> obfuscatedMappingPair in Mappings)
{
writer.WriteStartElement(MappingValueElement);
writer.WriteAttributeString(MappingMapsToAttribute, obfuscatedMappingPair.Value.Obfuscated);
writer.WriteString(obfuscatedMappingPair.Value.Original);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.Flush();
}
tempOutput.Position = 0;
output = tempOutput;
tempOutput = null;
}
finally
{
if (tempOutput != null)
{
tempOutput.Dispose();
}
}
return(output);
}
/// <summary>
/// Revert the obfuscated XML document of <paramref name="value"/> to its original state by applying the mappaple XML document of <paramref name="mapping"/>.
/// </summary>
/// <param name="value">The obfuscated <see cref="Stream"/> to revert.</param>
/// <param name="mapping">A <see cref="Stream"/> containing mappaple values necessary to revert <paramref name="value"/> to its original state.</param>
/// <returns>A <see cref="Stream"/> object where the obfuscated XML document has been reverted to its original XML document.</returns>
public override Stream Revert(Stream value, Stream mapping)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (mapping == null)
{
throw new ArgumentNullException(nameof(mapping));
}
long obfustatedStartingPosition = -1;
long mappingStartingPosition = -1;
if (value.CanSeek)
{
obfustatedStartingPosition = value.Position;
value.Position = 0;
}
if (mapping.CanSeek)
{
mappingStartingPosition = mapping.Position;
mapping.Position = 0;
}
IXPathNavigable document = XPathNavigableConverter.FromStream(mapping);
XPathNavigator navigator = document.CreateNavigator();
string mappingXpath = string.Format(CultureInfo.InvariantCulture, "{0}/{1}[@{2}='{3}']", MappingRootElement, MappingValueElement, MappingMapsToAttribute, "{0}");
MemoryStream output;
MemoryStream tempOutput = null;
try
{
tempOutput = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(tempOutput, XmlWriterUtility.CreateSettings(o => o.Encoding = Encoding)))
{
using (XmlReader reader = XmlReader.Create(value))
{
while (reader.Read())
{
bool writeEndElement = false;
switch (reader.NodeType)
{
case XmlNodeType.Attribute:
writer.WriteAttributeString(reader.Prefix, Exclusions.Contains(reader.LocalName) ? reader.LocalName : navigator.SelectSingleNode(string.Format(CultureInfo.InvariantCulture, mappingXpath, reader.LocalName)).Value, reader.NamespaceURI, Exclusions.Contains(reader.Value) ? reader.Value : navigator.SelectSingleNode(string.Format(CultureInfo.InvariantCulture, "{0}/{1}[@{2}='{3}']", MappingRootElement, MappingValueElement, MappingMapsToAttribute, reader.Value)).Value);
while (reader.MoveToNextAttribute())
{
goto case XmlNodeType.Attribute;
}
reader.MoveToElement();
break;
case XmlNodeType.Element:
writer.WriteStartElement(reader.Prefix, Exclusions.Contains(reader.LocalName) ? reader.LocalName : navigator.SelectSingleNode(string.Format(CultureInfo.InvariantCulture, mappingXpath, reader.LocalName)).Value, reader.NamespaceURI);
writeEndElement = reader.IsEmptyElement;
if (reader.HasAttributes)
{
if (reader.MoveToFirstAttribute())
{
goto case XmlNodeType.Attribute;
}
}
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
break;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
break;
case XmlNodeType.DocumentType:
writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.Text:
writer.WriteString(Exclusions.Contains(reader.Value) ? reader.Value : navigator.SelectSingleNode(string.Format(CultureInfo.InvariantCulture, mappingXpath, reader.Value)).Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(reader.Value);
break;
case XmlNodeType.CDATA:
writer.WriteCData(Exclusions.Contains(reader.Value) ? reader.Value : navigator.SelectSingleNode(string.Format(CultureInfo.InvariantCulture, mappingXpath, reader.Value)).Value);
break;
case XmlNodeType.EntityReference:
writer.WriteEntityRef(reader.Name);
break;
}
if (writeEndElement)
{
writer.WriteEndElement();
}
}
}
writer.Flush();
}
tempOutput.Position = 0;
output = tempOutput;
tempOutput = null;
}
finally
{
if (tempOutput != null)
{
tempOutput.Dispose();
}
}
if (value.CanSeek)
{
value.Seek(obfustatedStartingPosition, SeekOrigin.Begin);
}
if (mapping.CanSeek)
{
mapping.Seek(mappingStartingPosition, SeekOrigin.Begin);
}
return(output);
}
/// <summary>
/// Obfuscates the XML document of the specified <see cref="Stream"/> object.
/// </summary>
/// <param name="value">The <see cref="Stream"/> object to obfuscate.</param>
/// <returns>A <see cref="Stream"/> object where the XML document has been obfuscated.</returns>
public override Stream Obfuscate(Stream value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
long startingPosition = value.Position;
if (value.CanSeek)
{
value.Position = 0;
}
MemoryStream output;
MemoryStream tempOutput = null;
try
{
tempOutput = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(tempOutput, XmlWriterUtility.CreateSettings(o => o.Encoding = Encoding)))
{
using (XmlReader reader = XmlReader.Create(value))
{
while (reader.Read())
{
bool writeEndElement = false;
switch (reader.NodeType)
{
case XmlNodeType.Attribute:
WriteAttributeString(writer, reader);
while (reader.MoveToNextAttribute())
{
WriteAttributeString(writer, reader);
}
reader.MoveToElement();
break;
case XmlNodeType.Element:
WriteStartElement(writer, reader);
writeEndElement = reader.IsEmptyElement;
if (reader.HasAttributes)
{
if (reader.MoveToFirstAttribute())
{
goto case XmlNodeType.Attribute;
}
}
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
break;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
break;
case XmlNodeType.DocumentType:
writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.Text:
WriteString(writer, reader);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(reader.Value);
break;
case XmlNodeType.CDATA:
WriteCData(writer, reader);
break;
case XmlNodeType.EntityReference:
writer.WriteEntityRef(reader.Name);
break;
}
if (writeEndElement)
{
writer.WriteEndElement();
}
}
}
writer.Flush();
}
tempOutput.Position = 0;
output = tempOutput;
tempOutput = null;
}
finally
{
if (tempOutput != null)
{
tempOutput.Dispose();
}
}
if (value.CanSeek)
{
value.Seek(startingPosition, SeekOrigin.Begin);
} // reset to original position
return(output);
}
