Reader Level:
Articles

Creating a more secure 'keyless' cipher using C#

By Vulpes on April 11, 2012
In this article, I’d like to review two of the commonest keyless ciphers and discuss what can be done to make them sufficiently secure so we could use them in our programs.
  • 0
  • 0
  • 5980
Download Files:
 

Introduction

As the name suggests, a 'keyless' cipher is a cipher where the user does not need to provide a key to encrypt or decrypt a piece of text. The key, if there is one, is implicit from the algorithm used.

This means, of course, that you don't have to worry about how or where to store the key or key file for your encryption system. However, keyless systems are not usually secure due to the nature of the algorithms used.

ROT13

This is perhaps the best known keyless cipher. Every letter in the plain text is rotated by 13 places in the alphabet. When 'Z' is reached, the cipher wraps around to 'A' so it's really just a simple substitution cipher:

Text A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
Code N O P Q R S T U V W X Y Z A B C D E F G H I J K L M

Only upper and lower case letters are rotated in this way. All other characters (include spaces) remain unaltered.

So C# Corner in ROT13 would be : P# Pbeare.

An interesting property of ROT13 is that you can apply the same method for both encryption and decryption.

Although it's used for various purposes on the Internet, ROT13 has no pretensions to being secure. If you know that something has been encrypted using ROT13, then there are several online utilities available which can recover the plain text and, even if you don't, then it's easily defeated using frequency analysis.

There is a variation known as ROT5 which can be used for encrypting the numerals 0 to 9 by rotating them 5 places to the right and wrapping around to 0 when 9 is reached. This can also be used in conjunction with ROT13 to encrypt alphanumeric text.

ROT47


ROT47 is a keyless cipher based on the same principles as ROT13 which encrypts all the printable ASCII characters (excluding spaces) between codepoints 33 (exclamation mark) and 126 (tilde), a range of 94 characters, by rotating them 47 places to the right and wrapping around to character 33 when character 126 is reached.
So C# Corner in ROT47 would be: rR r@C?6C.

As in the case of ROT13, you can apply the same method for both encryption and decryption and, although the encryption is more thorough, it can still be defeated using frequency analysis.

Also it can be more error-prone to write down the cipher text than ROT13 because of the use of symbols as well as letters and numerals.

ROT1035

You won't find this one in the text books as it's my own variation of ROT13.

It differs from it in that the consonants are rotated separately (by 10 places) from the vowels (by 3 places). The vowels for this purpose include 'Y'. The numerals are also rotated 5 places, as in ROT5.

So C# Corner in ROT1035 would be : P# Pafbuf.

As each word of the cipher text will include as many vowels as it did in the first place, the result is something that looks like it could be an obscure foreign language rather than encrypted text.

Also, if any one attempts to decrypt it using ROT13, the result is gibberish.

You can still apply the same method for both encryption and decryption but it is just as susceptible to defeat by frequency analysis as the other ROT variants.

ROTA

So is there anything we can do to make ROT1035 more secure?

The problem at the moment is that the various categories of character are always rotated by the same number of places. Suppose we were to make the number of places to rotate (or 'offsets') variable depending on the index of the character in the string and not just in a predictable way but in a more random fashion. Suppose also that the starting point within this sequence of offsets were made variable as well depending on the total number of characters in the string.

The result is an encryption scheme I've called ROTA which is much harder to crack than the other ROT variants though at the expense of requiring different methods for encryption and decryption.

C# Corner in ROTA would be : J# Bitgiv.

The encrypted text has similar properties to ROT1035 except that repeated words are (usually) encrypted differently which makes attacks using frequency analysis much more difficult.

The sequence of 'offsets' for letters was found by using the perfect pangram, junky qoph-flags vext crwd zimb (see http://en.wikipedia.org/wiki/List_of_pangrams ) and converting the letters to their consonant or vowel numbers in the alphabet which gives reasonably random results. The sequence for numerals uses the letters 'a' to 'j' from this pangram. Other pangrams or approaches could, of course, be used to generate these sequences.

Arguably, it would have been more secure to recombine the vowels and consonants into a single sequence (as in ROT13) so as not to offer a possible 'way in' by studying the vowels in single letter or other short words but I decided against this.

Source Code

I've coded a method for each of these variants (ROTA uses a static class with two methods) so we can compare the output. The following program is also available as a download:

using System;
 
class Program
{
    static void Main()
    {
        string[] s = new string[2];
        s[0] = "The Quick Brown Fox Jumps Over The Lazy Dog 2012";
// Dog
        s[1] = "The Quick Brown Fox Jumps Over The Lazy Dogs 2012"; // now Dogs 
       
        for (int i = 0; i < 2; i++)
        {
            Console.WriteLine("Using ROT13\n");
            string t = ROT13(s[i]);
            Console.WriteLine(t);
            Console.WriteLine(ROT13(t));
 
            Console.WriteLine("\nUsing ROT47\n");
            string u = ROT47(s[i]);

            Console.WriteLine(u);
            Console.WriteLine(ROT47(u));
 
            Console.WriteLine("\nUsing ROT1035\n");
            string v = ROT1035(s[i]);
            Console.WriteLine(v);
            Console.WriteLine(ROT1035(v));
 
            Console.WriteLine("\nUsing ROTA\n");
            string w = ROTA.Encrypt(s[i]);
            Console.WriteLine(w);
            Console.WriteLine(ROTA.Decrypt(w)); 
            Console.WriteLine("\n" + new string('-', s[i].Length) + "\n");
        } 
        Console.ReadKey();            
    }
 
    static string ROT13(string s)
    {
        if (String.IsNullOrEmpty(s)) return s;
        char[] ca = new char[s.Length]; 
        for (int i = 0; i < s.Length; i++)
        {
            char c = s[i]; 
            if (c >= 97 && c <= 122)
            {
                int j = c + 13;
                if (j > 122) j -= 26;
                ca[i] = (char)j;
            }
            else if (c >= 65 && c <= 90)
            {
                int j = c + 13;
                if (j > 90) j -= 26;
                ca[i] = (char)j;
            }
           
else
            {
                ca[i] = c;
            }
        } 
        return new string(ca);
    }
 
    static string ROT47(string s)
    {
        if (String.IsNullOrEmpty(s)) return s;
        char[] ca = new char[s.Length]; 

        for (int i = 0; i < s.Length; i++)
        {
            char c = s[i];
 
            if (c >= 33 && c <= 126)
            {
                int j = c + 47;
                if (j > 126) j -= 94;
                ca[i] = (char)j;
            }
           
else
            {
                ca[i] = c;
            }
        } 
        return new string(ca);
    }
 
    static string ROT1035(string s)
    {
        if (String.IsNullOrEmpty(s)) return s;
        string consonants = "bcdfghjklmnpqrstvwxz";
        string vowels = "aeiouy"
        char[] ca = new char[s.Length];
 
        for (int i = 0; i < s.Length; i++)
        {
            char c = s[i]; 
            int j;
 
            if ((j = vowels.IndexOf(c)) > -1)
            {
                j += 3;
                if (j > 5) j -= 6;
                ca[i] = vowels[j];
            }
            else if ((j = consonants.IndexOf(c)) > -1)
            {
                j += 10;

                if (j > 19) j -= 20;
                ca[i] = consonants[j];
            }
            else if ((j = vowels.ToUpper().IndexOf(c)) > -1)
            {
                j += 3;
                if (j > 5) j -= 6;
                ca[i] = vowels.ToUpper()[j];
            }
            else if ((j = consonants.ToUpper().IndexOf(c)) > -1)
            {
                j += 10;
                if (j > 19) j -= 20;
                ca[i] = consonants.ToUpper()[j];
            }
            else if (c >= 48 && c <= 57)
            {
                j = c + 5;
                if (j > 57) j -= 10;
                ca[i] = (char)j;
            }
           
else
            {
                ca[i] = c;
            }
        }
 
        return new string(ca);
    }
}
 
static class ROTA
{
    static int[] keyC = { 7, 11, 8, 13, 12, 6, 4, 9, 5, 15, 17, 19, 16, 2, 14, 18, 3, 20, 10, 1 };
    static int[] keyV = { 5, 6, 4, 1, 2, 3 };
    static int[] keyN = { 10, 8, 6, 1, 7, 5, 3, 4, 9, 2 };
    static string consonants = "bcdfghjklmnpqrstvwxz";
    static string vowels = "aeiouy";
 
    public static string Encrypt(string s)
    {
        if (String.IsNullOrEmpty(s)) return s;
 
        int lenC = (s.Length - 1) % 20;
        int lenV = (s.Length - 1) % 6;
        int lenN = (s.Length - 1) % 10;
 
        char[] ca = new char[s.Length];
 
        for (int i = 0; i < s.Length; i++)
        {
            char c = s[i];
 
            int j;
 
            if ((j = vowels.IndexOf(c)) > -1)
            {
                j += keyV[(i + lenV) % 6];
                if (j > 5) j -= 6;
                ca[i] = vowels[j];
            }
            else if ((j = consonants.IndexOf(c)) > -1)
            {
                j += keyC[(i + lenC) % 20];
                if (j > 19) j -= 20;
                ca[i] = consonants[j];
            }
            else if ((j = vowels.ToUpper().IndexOf(c)) > -1)
            {
                j += keyV[(i + lenV) % 6];
                if (j > 5) j -= 6;
                ca[i] = vowels.ToUpper()[j];
            }
            else if ((j = consonants.ToUpper().IndexOf(c)) > -1)
            {
                j += keyC[(i + lenC) % 20];
                if (j > 19) j -= 20;
                ca[i] = consonants.ToUpper()[j];
            }
            else if (c >= 48 && c <= 57)
            {
                j = c + keyN[(i + lenN) % 10];
                if (j > 57) j -= 10;
                ca[i] = (char)j;
            }
           
else
            {
                ca[i] = c;
            }
        }
 
        return new string(ca);
    }
 
    public static string Decrypt(string s)
    {
        if (String.IsNullOrEmpty(s)) return s;
 
        int lenC = (s.Length - 1) % 20;
        int lenV = (s.Length - 1) % 6;
        int lenN = (s.Length - 1) % 10;
 
        char[] ca = new char[s.Length];
 
        for (int i = 0; i < s.Length; i++)
        {
            char c = s[i]; 
            int j; 
            if ((j = vowels.IndexOf(c)) > -1)
            {
                j -= keyV[(i + lenV) % 6];
                if (j < 0) j += 6;
                ca[i] = vowels[j];
            }
            else if ((j = consonants.IndexOf(c)) > -1)
            {
                j -= keyC[(i + lenC) % 20];
                if (j < 0) j += 20;
                ca[i] = consonants[j];
            }
            else if ((j = vowels.ToUpper().IndexOf(c)) > -1)
            {
                j -= keyV[(i + lenV) % 6];
                if (j < 0) j += 6;
                ca[i] = vowels.ToUpper()[j];
            }
            else if ((j = consonants.ToUpper().IndexOf(c)) > -1)
            {
                j -= keyC[(i + lenC) % 20];
                if (j < 0) j += 20;
                ca[i] = consonants.ToUpper()[j];
            }
            else if (c >= 48 && c <= 57)
            {
                j = c - keyN[(i + lenN) % 10];
                if (j < 48) j += 10;
                ca[i] = (char)j;
            }
           
else
            {
                ca[i] = c;
            }
        } 
        return new string(ca);
    }
}


Results

The following is a screen-shot of the output from this program:

keyless.gif

Notice that the second "the" is encoded differently in ROTA but not in the other variants.

Notice also that changing "Dog" to "Dogs" only changes the encrypted version of that particular word when using the first three variants. However, when using ROTA it changes the whole sentence!

Conclusion

It's therefore clear that ROTA is much more secure than the other ROT variants.

However, it's still not cryptographically strong by modern standards - an expert would have no trouble deciphering it.

It could be made stronger by adding other refinements such as changing the spacing between words but I didn't think that this would be worthwhile.

The important thing is to produce a keyless cipher which is quick and easy to use and could be used (for example) to encrypt string literals or small files and so protect them from casual inspection. I believe that ROTA already achieves this limited aim.

COMMENT USING

Trending up