/// <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> /// 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); }