A ROT-13 implementation in CSharp
ROT-13 is a simple substitution cipher where the current character is rotated by 13 characters, which finds its symmetrical opposite in the modern English alphabet. This property allows the cipher to be reciprocal and therefore it can be used to obfuscate a clear text string and also transform the obfuscated string back into its original clear text equivalent.
I use the term obfuscation in the previous paragraph to emphasize the fact that the ROT-13 cipher is not secure and any obfuscated strings can be easily reversed simply by knowing that a ROT-13 cipher has been used.
The Implementation
The implementation of the cipher is really simple and there are many approaches
that one can use to achieve the same outcome. The one I chose is based on a
lookup table that I initially build and then use many times. This is basically
the same approach used in the Python module this (enter import this on a
python prompt). You can see the implementation by finding the this.py file
that comes with your python implementation.
The lookup table that I use is implemented using a generic dictionary. When the
Rot13 function is called, I check if the lookup table exists and if it
doesn't, I'll build it. I use the seeds 65 and 97, which are the ASCII values
for A and a respectively, and from there I move 26 values to the right while
applying a modulo 26, which tells me if I need to wrap-around to the beginning.
Once the lookup table is built, I can use it by simply going over the string
parameter passed into Rot13, and substituting each character in the string by
the corresponding value in the lookup table. This is what it looks like:
private Dictionary<char, char> d = null;
public string Rot13(string s) {
if (d == null || d.Count == 0) { // build the lookup table
d = new Dictionary<char, char>(); // if needed
int[] sr = { 65, 97 }; // A=65; a=97; ASCII Codes
foreach (int c in sr) {
for (int i = 0; i < 26; i++) { // 26 alpha chars
d.Add((char)(i + c), (char)((i + 13) % 26 + c));
}
}
}
StringBuilder sb = new StringBuilder();
foreach (var item in s.ToCharArray()) {
if (d.ContainsKey(item)) // Worry only about alpha characters
sb.Append(d[item]); // leave number, etc. untouched
else
sb.Append(item);
}
return sb.ToString();
}
Using the Algorithm
To use the ROT-13 cipher algorithm above, you simply have to call the
Rot13 function and send it a string parameter which represents the
string you want to obfuscate. In the example code below the Main
function uses a command line argument passed in:
static void Main(string[] args) {
if (args.Length == 0) {
WL("Please provide a string to obfuscate using the ROT 13 cypher.");
Environment.Exit(0);
}
Program p = new Program();
WL(String.Format("Original String: {0}", args[0]));
WL(String.Format("Obfuscated String: {0}", p.Rot13(args[0])));
WL(String.Format("De-Obfuscated String: {0}", p.Rot13(p.Rot13(args[0]))));
WL("\nPress enter to continue...");
RL();
}
static Func<string> RL = () => Console.ReadLine();
static Action<Object> WL = obj => Console.WriteLine(obj);</pre>
If you call the Rot13.exe program like this:
H:\>Rot13.exe HELLO
Your output will be the following:
Original String: HELLO Obfuscated String: URYYB De-Obfuscated String: HELLO Press enter to continue...
Conclusion
I am teaching myself cryptography and security concepts and I am using this venue to write my notes and solidify my ideas on this topic. I will be filing these under the crypto and security tags.