Scrambling Text Elements in XML

Question

How is it possible to take an XML document and in .Net scramble all text elements to make them un-readable to a human?

E.g. Make

<root><Node1>My Name is Ben</Node1></root>

Into

<root><Node1>klj sdlasd asdjfl</Node1></root>

---

Points:

• We only need scrambling not encryption, i.e. not human readable at a glance. It doesn’t matter if the user could de-code it with 30 seconds effort.
• We don’t know the schema of the XML, so all text elements must be located in code.
• We need to de-scramble the XML later – so please show how one would do that too.
• It needs to be simple, e.g. no pre-sharing keys, certificates, etc.
• Only the text elements should be scrambled - not the nodes, attributes, etc.

Answer 1

It would be simpler to just use the built in encryption classes in the .NET framework if you're trying to obfuscate it, than building a scrambling class. If security isn't your concern, then just hard-code the password and initialization vector.

Out of curiosity, why would you scramble it, only to have it human-readable with little effort?

Answer 2

you can implement your own ROT13 code.

Answer 3

The simplest two-way encryption I can think of is to just take the ASCII value of each character and add a constant to it, say 3. Then convert it back by subtracting 3 from each character.

Original:

Hello this is scrambled.

Scrambled:

Khoor#wklv#lv#vfudpeohg1

Python code because I love Python too much:

def scramble(str):
    return ''.join([chr(ord(c)+3) for c in str])

def unscramble(str):
    return ''.join([chr(ord(c)-3) for c in str])

Answer 4

You could just use a Caesar cipher on each node's contents.

Answer 5

Just use Convert.ToBase64String and Convert.FromBase64String

Has the additonal advantage of ensuring that you don't have to worry about escaping characters, although it does increase the length of the strings a bit.

Answer 6

To identify the text elements, load the unscrambled XML data into an XmlDocument. Then recursively walk down the ChildNodes collection, checking the XmlNode.NodeType of each node. If it's XmlNodeType.Text, then it's a piece of text.

If you also want to scramble attribute values, then look out for XmlNodeType.Attribute as well.

Answer 7

using System;
using System.Linq;
using System.Xml.Linq;
using System.Collections.Generic;

namespace App
{
    class Scrambler
    {
        public static void ScrambleTextNodes(XContainer xml)
        {
            foreach (XText textNode in GetDescendantTextNodes(xml))
                textNode.Value = Scramble(textNode.Value);
        }

        public static void UnScrambleTextNodes(XContainer xml)
        {

            foreach (XText textNode in GetDescendantTextNodes(xml))
                textNode.Value = UnScramble(textNode.Value);
        }

        public static IEnumerable<XNode> GetDescendantTextNodes(XContainer xml)
        {
            return xml.DescendantNodes().Where(node => node.NodeType == System.Xml.XmlNodeType.Text);
        }

        public static string Scramble(string s)
        {
            var a = s.Select(ch => (char)(ch + 3)).ToArray();
            return new string(a);
        }

        public static string UnScramble(string s)
        {
            var a = s.Select(ch => (char)(ch - 3)).ToArray();
            return new string(a);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var doc = XDocument.Parse("<a><b>this</b><b><c>is</c><c><d>a test</d></c></b></a>");

            Scrambler.ScrambleTextNodes(doc);

            Console.WriteLine(doc.ToString());

            Scrambler.UnScrambleTextNodes(doc);

            Console.WriteLine(doc.ToString());

            Console.ReadLine();
        }

    }
}

Output:

<a>
  <b>wklv</b>
  <b>
    <c>lv</c>
    <c>
      <d>d whvw</d>
    </c>
  </b>
</a>
<a>
  <b>this</b>
  <b>
    <c>is</c>
    <c>
      <d>a test</d>
    </c>
  </b>
</a>

You can always use some other scrambling algorithm. The scrambling itself is a translation to C# of Kai's Python answer.

edit: clean-up :) edit2: removed the check to not scramble spaces. This would cause the unscrambling to be incorrect at times...