Tuesday, March 27, 2012

Disk Cipher Algorithms in C

The disk cipher is a combination of the Caesar Cipher and the Simple Substitution Cipher. It resembles  the Simple Substitution Cipher because it uses two predefined alphabets and it resembles the Caesar Cipher because the substitution is done according to a predefined shift.

Learn more about the Caesar Cipher.
Learn more about the Simple Substitution Cipher.

If you want to read more about the history of the disk cipher, you can check out  this article.

In order to implement the algorithm in C, we shall use the following enumeration who shall reflect if an encoding/decoding operation was completed correctly.
typedef enum
{
 OPERATION_SUCCESS = 1U,
 OPERATION_FAILED = 0U,
}OPERATION_STATUS;
1.The Encoding Algorithm

The encoding algorithm is very similar to the one used for the Simple Substitution Cipher, except that the shift will be added to the position (and a modulo operation shall be used in order to avoid overflow).  In order to obtain the position of the encoded symbol, the following formula shall be used:
where:
  • j - the position of the symbol in the cipher text (coded alphabet)
  • Ei - the position of the symbol from the original message in the original alphabet (plain text)
  • s - the shift value
  • O - the original alphabet
OPERATION_STATUS DiskCipher_Encode(char* originalAlphabet,
                                   char* codedAlphabet,
                                   char* originalMessage,
                                   char* encodedMessage,
                                   unsigned short shift)
{
 unsigned short alphabetLength = strlen(originalAlphabet);
 unsigned int messageLength    = strlen(originalMessage);
 unsigned int i = 0U;
 char* pointer = NULL;
 unsigned int position = 0U;
 if( alphabetLength != strlen(codedAlphabet) )
 {
  //The lengths of the alphabets do not match
  return OPERATION_FAILED;
 }
 for(i=0; i<messageLength; i++)
 {
  pointer  = strchr(originalAlphabet, originalMessage[i]);
  if(pointer==NULL)
  {
   //A character in the message was not found in the
   //original alphabet
   return OPERATION_FAILED;
  }
  else
  {
   position = ((pointer - originalAlphabet) + shift)%alphabetLength;
   encodedMessage[i] = codedAlphabet[position];
  }
 }
 encodedMessage[messageLength] = '\0';
 return OPERATION_SUCCESS;
}
The function receives 5 parameters:
  • originalAlphabet - a pointer to a string containing the plain text alphabet (who has all the letters that appear in the originalMessage). All symbols in the originalAlphabet should appear only once.
  • codedAlphabet - a pointer to a string containing the cipher text alphabet (who has the same length as the originalAlphabet string). All symbols in the codedAlphabet should appear only once.
  • originalMessage - a pointer to a string containing the message who will be encoded
  • codedMessage - a pointer to a pre-allocated empty string who will contain the encoded message.
  • shift - what is the offset value used for the substitution
The function returns OPERATIONS_SUCCES if all preconditions have been respected, respectively OPERATON_FAILED if the lengths of the alphabets are different or if the function found a symbol in the original message who has not been defined in the originalAlphabet.

2.The Decoding Algorithm

The decoding algorithm shall do the inverse operation of encoding. Instead of adding the shift, the shift will be subtracted. In order to obtain the position of the decoded symbol, the following formula shall be used:
where:
                                       
  • j - the position of decoded symbol in the plain text (original Alphabet)
  • Ci - the position of the symbol from the encoded message in the cipher text (coded alphabet)
  • s - the shift value
  • O - the length of the original alphabet
OPERATION_STATUS DiskCipher_Decode(char* originalAlphabet,
                                   char* codedAlphabet,
                                   char* encodedMessage,
                                   char* decodedMessage,
                                   unsigned short shift)
{
 unsigned short alphabetLength = strlen(originalAlphabet);
 unsigned int messageLength    = strlen(encodedMessage);
 unsigned int i = 0U;
 char* pointer = NULL;
 unsigned int position = 0U;
 if( alphabetLength != strlen(codedAlphabet) )
 {
  //The lengths of the alphabets do not match
  return OPERATION_FAILED;
 }
 for(i=0; i<messageLength; i++)
 {
  pointer  = strchr(codedAlphabet, encodedMessage[i]);
  if(pointer==NULL)
  {
   //A character in the message was not found in the
   //coded alphabet
   return OPERATION_FAILED;
  }
  else
  {
   position = (abs(alphabetLength + (pointer - codedAlphabet) - shift))
      %alphabetLength;
   decodedMessage[i] = originalAlphabet[position];
  }
 }
 decodedMessage[messageLength] = '\0';
 return OPERATION_SUCCESS;
}
The function receives 5 parameters:
  • originalAlphabet - a pointer to a string containing the plain text alphabet (who has all the letters that appear in the originalMessage). All symbols in the originalAlphabet should appear only once.
  • codedAlphabet - a pointer to a string containing the cipher text alphabet (who has the same length as the originalAlphabet string). All symbols in the codedAlphabet should appear only once.
  • encodedMessage - a pointer to a string containing the message who will be encoded
  • decodedMessage - a pointer to a pre-allocated empty string who will contain the decoded message.
  • shift - what is the offset value used for the substitution
The function returns OPERATIONS_SUCCES if all preconditions have been respected, respectively OPERATON_FAILED if the lengths of the alphabets are different or if the function found a symbol in the encoded message who has not been defined in the coded Alphabet.

3.Example
Here's a short example on how to use the functions described above:
char originalAlphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
char codedAlphabet[]    = "QWERTYUIOPASDFGHJKLZXCVBNM#";
char originalMessage[]  = "DISK CIPHER";
char encodedMessage[12];
char decodedMessage[12];
unsigned int shift = 15;
DiskCipher_Encode(originalAlphabet, codedAlphabet,
    originalMessage, encodedMessage,shift);
puts(encodedMessage);
DiskCipher_Decode(originalAlphabet, codedAlphabet,
    encodedMessage, decodedMessage,shift);
puts(decodedMessage);

Saturday, March 24, 2012

Simple Substitution Cipher Algorithms in C

A substitution cipher is a method of encryption by which units of the original alphabet (or plain text) are replaced with units of a coded alphabet (or cipher text) according to a regular system. The units may be single letters, two letters or triplets or letters, etc. A simple substitution cipher uses operates with single letter units.

To encrypt a message using a substitution cipher one needs the plain text alphabet (original alphabet) and the cipher text alphabet (the coded alphabet) which shall serve as a private key.
The formula for the substitution is:
  • Ei represents the i-th character from the encoded string
  • Cj represents the j-th character from the cipher text alphabet, where j represents the position of the Ei character in the original alphabet.
In order to implement such algorithm we shall define the following enumeration:
typedef enum
{
 OPERATION_SUCCESS = 1U,
 OPERATION_FAILED  = 0U
}OPERATION_STATUS;
Below you can see the C implementation for the algorithm:
OPERATION_STATUS SimpleSubstitutionCipher_Code(char* originalAlphabet,
                                               char* codedAlphabet,
                                               char* originalMessage,
                                               char* encodedMessage)
{
 unsigned short alphabetLength = strlen(originalAlphabet);
 unsigned int messageLength    = strlen(originalMessage);
 unsigned int i = 0U;
 char* pointer = NULL;
 unsigned int position = 0U;
 if( alphabetLength != strlen(codedAlphabet) )
 {
  //The lengths of the alphabets do not match
  return OPERATION_FAILED;
 }
 for(i=0; i<messageLength; i++)
 {
  pointer  = strchr(originalAlphabet, originalMessage[i]);
  if(pointer==NULL)
  {
   //A character in the message was not found in the
   //original alphabet
   return OPERATION_FAILED;
  }
  else
  {
   position = pointer - originalAlphabet;
   encodedMessage[i] = codedAlphabet[position];
  }
 }
 encodedMessage[messageLength] = '\0';
 return OPERATION_SUCCESS;
}
The function receives 4 parameters:
  • originalAlphabet - a pointer to a string containing the plain text alphabet (who has all the letters that appear in the originalMessage). All symbols in the originalAlphabet should appear only once.
  • codedAlphabet - a pointer to a string containing the cipher text alphabet (who has the same length as the originalAlphabet string). All symbols in the codedAlphabet should appear only once.
  • originalMessage - a pointer to a string containing the message who will be encoded
  • codedMessage - a pointer to a pre-allocated empty string who will contain the encoded message.
The function returns OPERATIONS_SUCCES if all preconditions have been respected, respectively OPERATON_FAILED if the lengths of the alphabets are different or if the function found a symbol in the original message who has not been defined in the originalAlphabet.

A simple encoding/decoding example
 char originalAlphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
 char codedAlphabet[]    = "QWERTYUIOPASDFGHJKLZXCVBNM#";
 char originalMessage[]  = "SUBSTITUTION CIPHER";
 char encodedMessage[20];
 char decodedMessage[20];
 //Encoding
 SimpleSubstitutionCipher_Code(originalAlphabet,codedAlphabet,
                               originalMessage, encodedMessage);
 puts(encodedMessage);
 //Decoding
 SimpleSubstitutionCipher_Code(codedAlphabet,originalAlphabet,
                               encodedMessage, decodedMessage);
 puts(decodedMessage);
As you probably already observed, the same function is used for both encryption and decryption. This is because the same operations are performed in both cases.

Sunday, March 11, 2012

Customizing the Gnome 3 Applications Menu with Alacarte

The Gnome 3 Applications menu can contain launchers to all the applications you installed, but showing all of them can bring a drawback in performance, especially when you search for one in particular or at startup.

The solution is to display only the launchers you need and hide/remove the rest.

Also, some system updates tend to duplicate some of your launchers, so knowing how to remove/hide them can make your life easier.
Gnome 3 Activities Applications Panel
You can easily customize the visible launchers by using the Gnome menu editor Alacarte:
1)Open a terminal console (Ctrl + Alt +t)
2)Type:
alacarte 
This should open the Gnome Menu Editor like in the picture below:
Showing/Hiding Applications
In the middle window you can see two columns: Show and Item. 

If you uncheck the checkbox on the Show column the item will no longer be visible when you will enter the Applications Menu.

You can also delete and add new applications to the Applications menu:
  • To add a new launcher, click on the New Item button to the right. This will trigger a dialog like in the image below.
  • To remove a application, select it in the central window and then click on the Delete button to the right. Remember, once a launcher is deleted there is no turning back, so use this option with caution.
  • To add a new menu (like Accessories, Education, etc), click on the New Menu button to the right.
  • To see what's behind a launcher click the Properties button on the right. The dialog triggered will be similar to the one in the image below.



Related Posts Plugin for WordPress, Blogger...