Description:-
In this Article we will encrypt and Decrypt Text using cipher Encryption in Console Application. Here you can insert your Cipher Text for Encrypt and Decrypt your Text Data in Cipher text.
How does the cipher
work?
For full details of how the cipher is applied, you should consult Mr Rubin's paper which, by cryptographic standards, is very easy to read and understand.
For full details of how the cipher is applied, you should consult Mr Rubin's paper which, by cryptographic standards, is very easy to read and understand.
Briefly, the idea is
that you start with two alphabets: a 'left' alphabet (for ciphertext) and a
'right' alphabet (for plaintext).
You then convert each letter in the plaintext to ciphertext by looking up the index of the former in the right alphabet and then using that index of read off the corresponding ciphertext letter from the left alphabet.
However, unlike a normal substitution cipher, you then make some permutations to both the left and right alphabets before encrypting the next letter. Similar operations are carried out after encrypting each letter until the plaintext is exhausted.
Decryption follows a similar pattern except that the permutations used are slightly different from those used in encryption.
This is a clever idea which is known as an 'autokey' cipher in cryptography because the next key is generated from the previous one. Clearly, the permutations used need to be such that they can be easily reversed by the decryption process.
C# Implementation
Although a C# implementation is said to exist, I could not find it on the internet and so have written my own.
The following console application is based on the algorithm described in Mr Rubin's paper and uses the example which he gives so we can check that it is working correctly. The resulting ciphertext is then decrypted back to the plaintext.
No attempt has been made to optimize the code though, for a large piece of plaintext, performance could almost certainly be improved by using unsafe code and pointers to manipulate the character arrays.
You then convert each letter in the plaintext to ciphertext by looking up the index of the former in the right alphabet and then using that index of read off the corresponding ciphertext letter from the left alphabet.
However, unlike a normal substitution cipher, you then make some permutations to both the left and right alphabets before encrypting the next letter. Similar operations are carried out after encrypting each letter until the plaintext is exhausted.
Decryption follows a similar pattern except that the permutations used are slightly different from those used in encryption.
This is a clever idea which is known as an 'autokey' cipher in cryptography because the next key is generated from the previous one. Clearly, the permutations used need to be such that they can be easily reversed by the decryption process.
C# Implementation
Although a C# implementation is said to exist, I could not find it on the internet and so have written my own.
The following console application is based on the algorithm described in Mr Rubin's paper and uses the example which he gives so we can check that it is working correctly. The resulting ciphertext is then decrypted back to the plaintext.
No attempt has been made to optimize the code though, for a large piece of plaintext, performance could almost certainly be improved by using unsafe code and pointers to manipulate the character arrays.
Step 1: Create Console Application and Code below to understand
how it works.
static void Main(string[] args)
{
string plainText = "UMESHPATELAHMEDABAD";
Console.WriteLine("The original plainText is : {0}", plainText);
Console.WriteLine("\nThe left and right alphabets after each
permutation during encryption are\n");
string cipherText = Chao.Encrypt(plainText);
Console.WriteLine("\nThe ciphertext is {0}\n", cipherText);
string plainText2 = Chao.Decrypt(cipherText);
Console.WriteLine("\nThe recovered plaintext is {0}", plainText2);
Console.ReadKey();
}
static class Chao
{
private static string lAlphabet = "HXUCZVAMDSLKPEFJRIGTWOBNYQ";
private static string rAlphabet = "PTLNBQDEOYSFAVZKGJRIHWXUMC";
public static string Encrypt(string plainText)
{
char[] left = lAlphabet.ToCharArray();
char[] right = rAlphabet.ToCharArray();
char[] pText = plainText.ToCharArray();
char[] cText = new char[pText.Length];
char[] temp = new char[26];
int index;
char store;
for (int i = 0; i < pText.Length; i++)
{
Console.WriteLine("{0} {1}", new string(left), new string(right));
index = Array.IndexOf(right, pText[i]);
cText[i] = left[index];
if (i == pText.Length -
1) break;
// permute left
for (int j = index; j < 26; j++) temp[j - index] = left[j];
for (int j = 0; j < index; j++) temp[26 - index + j] = left[j];
store = temp[1];
for (int j = 2; j < 14; j++) temp[j - 1] = temp[j];
temp[13] = store;
temp.CopyTo(left, 0);
// permute right
for (int j = index; j < 26; j++) temp[j - index] = right[j];
for (int j = 0; j < index; j++) temp[26 - index + j] = right[j];
store = temp[0];
for (int j = 1; j < 26; j++) temp[j - 1] = temp[j];
temp[25] = store;
store = temp[2];
for (int j = 3; j < 14; j++) temp[j - 1] = temp[j];
temp[13] = store;
temp.CopyTo(right, 0);
}
return new string(cText);
}
public static string Decrypt(string cipherText)
{
char[] left = lAlphabet.ToCharArray();
char[] right = rAlphabet.ToCharArray();
char[] cText = cipherText.ToCharArray();
char[] pText = new char[cText.Length];
char[] temp = new char[26];
int index;
char store;
for (int i = 0; i < cText.Length; i++)
{
Console.WriteLine("{0} {1}", new string(left), new string(right));
index = Array.IndexOf(left, cText[i]);
pText[i] = right[index];
if (i == cText.Length -
1) break;
// permute left
for (int j = index; j < 26; j++) temp[j - index] = left[j];
for (int j = 0; j < index; j++) temp[26 - index + j] = left[j];
store = temp[1];
for (int j = 2; j < 14; j++) temp[j - 1] = temp[j];
temp[13] = store;
temp.CopyTo(left, 0);
// permute right
for (int j = index; j < 26; j++) temp[j - index] = right[j];
for (int j = 0; j < index; j++) temp[26 - index + j] = right[j];
store = temp[0];
for (int j = 1; j < 26; j++) temp[j - 1] = temp[j];
temp[25] = store;
store = temp[2];
for (int j = 3; j < 14; j++) temp[j - 1] = temp[j];
temp[13] = store;
temp.CopyTo(right, 0);
}
return new string(pText);
}
}
My Output looks like below image.
The print out of the
left and right alphabets after each permutation during the decryption process
has been suppressed as the output would otherwise have exceeded the length of a
maximized console window on my machine.
I am not sure how strong this cipher is by modern cryptographic standards but clearly, relative to the effort needed to implement it, it is very strong indeed!
Although the present implementation only covers upper-case letters, it would be easy to adapt it to deal with larger character sets and, for those interested in developing their own ciphers, it should make an excellent starting point.
Thanks for comments.....