JAYPEE UNIVERSITY OF ENGINEERING AND

TECHNOLOGY
GUNA, M.P.

OPEN SOURCE SOFTWARE LAB

SEMESTER- 5

SUBMITTED BY- SUBMITTED TO-

Shreya Raizada. Dr. AMIT RATHI
191B247
B7 (BZ)
 Experiment No. 1
IMPLEMENTATION OF CAESAR CIPHER

AIM:
To implement the simple substitution technique named Caesar cipher using
C language.

DESCRIPTION:

To encrypt a message with a Caesar cipher, each letter in the message is

changed using a simple rule: shift by three. Each letter is replaced by the
letter three letters ahead in the alphabet. A becomes D, B becomes E, and so
on. For the last letters, we can think of alphabet as a circle and "wrap
around". W becomes Z, X becomes A, Y becomes B, and Z becomes C. To
change a message back, each letter is replaced by the one three before it.

EXAMPLE:

ALGORITHM:
STEP-1: Read the plain text from the user.
STEP-2: Read the key value from the user.
STEP-3: If the key is positive then encrypt the text by adding the key with
each
character in the plain text.
STEP-4: Else subtract the key from the plain text.
STEP-5: Display the cipher text obtained above.
Program:

#include<stdio.h>

int main()
{
char message[100], ch;
int i, key;
printf("Enter a message to encrypt: ");
gets(message);
printf("Enter key: ");
scanf("%d", &key);
for(i = 0; message[i] != '\0'; ++i){
ch = message[i];
if(ch >= 'a' && ch <= 'z'){
ch = ch + key;
if(ch > 'z'){
ch = ch - 'z' + 'a' - 1;
}
message[i] = ch;
}
else if(ch >= 'A' && ch <= 'Z'){
ch = ch + key;
if(ch > 'Z'){
ch = ch - 'Z' + 'A' - 1;
}
message[i] = ch;
}
}
printf("Encrypted message: %s", message);
return 0;
}

Output:
Enter a message to encrypt: axzd
Enter key: 4
Encrypted message: ebdh
 Experiment No. 2
IMPLEMENTATION OF PLAYFAIR CIPHER

AIM:

To implement the substitution technique named Playfair Substitution using

C language.

DESCRIPTION:

The Playfair cipher starts with creating a key table. The key table is a 5×5
grid of letters that will act as the key for encrypting your plaintext. Each of
the 25 letters must be unique and one letter of the alphabet is omitted from
the table (as there are 25 spots and 26 letters in the alphabet).

To encrypt a message, one would break the message into digrams (groups
of 2 letters) such that, for example, "HelloWorld" becomes "HELLO
WORLD", and map them out on
the key table. The two letters of the diagram are considered as the opposite
corners of a
rectangle in the key table. Note the relative position of the corners of this
rectangle. Then apply the following 4 rules, in order, to each pair of letters
in the plaintext:

1. If both letters are the same (or only one letter is left), add an "X" after the
first letter

2. If the letters appear on the same row of your table, replace them with the
letters to their immediate right respectively

3. If the letters appear on the same column of your table, replace them with
the letters immediately below respectively

4. If the letters are not on the same row or column, replace them with the
letters on the same row respectively but at the other pair of corners of the
rectangle defined by the original pair.

EXAMPLE:
ALGORITHM:

STEP-1: Read the plain text from the user.

STEP-2: Read the keyword from the user.
STEP-3: Arrange the keyword without duplicates in a 5*5 matrix in the row
order and fill the remaining cells with missed out letters in alphabetical
order. Note that ‘i’ and ‘j’ takes the same cell.
STEP-4: Group the plain text in pairs and match the corresponding corner
letters by forming a rectangular grid.
STEP-5: Display the obtained cipher text.

Solution:
#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define SIZE 30
void toLowerCase(char plain[], int ps)

int i;

for (i = 0; i < ps; i++) {

if (plain[i] > 64 && plain[i] < 91)

plain[i] += 32;

int removeSpaces(char* plain, int ps)

int i, count = 0;

for (i = 0; i < ps; i++)

if (plain[i] != ' ')

plain[count++] = plain[i];

plain[count] = '\0';

return count;

void generateKeyTable(char key[], int ks, char keyT[5][5])

int i, j, k, flag = 0, *dicty;

// a 26 character hashmap

// to store count of the alphabet

dicty = (int*)calloc(26, sizeof(int));

for (i = 0; i < ks; i++) {

if (key[i] != 'j')

dicty[key[i] - 97] = 2;
}

dicty['j' - 97] = 1;

i = 0;

j = 0;

for (k = 0; k < ks; k++) {

if (dicty[key[k] - 97] == 2) {

dicty[key[k] - 97] -= 1;

keyT[i][j] = key[k];

j++;

if (j == 5) {

i++;

j = 0;

for (k = 0; k < 26; k++) {

if (dicty[k] == 0) {

keyT[i][j] = (char)(k + 97);

j++;

if (j == 5) {

i++;

j = 0;

}
 }

void search(char keyT[5][5], char a, char b, int arr[])

int i, j;

if (a == 'j')

a = 'i';

else if (b == 'j')

b = 'i';

for (i = 0; i < 5; i++) {

for (j = 0; j < 5; j++) {

if (keyT[i][j] == a) {

arr[0] = i;

arr[1] = j;

else if (keyT[i][j] == b) {

arr[2] = i;

arr[3] = j;

}
int mod5(int a)

return (a % 5);

int prepare(char str[], int ptrs)

if (ptrs % 2 != 0) {

str[ptrs++] = 'z';

str[ptrs] = '\0';

return ptrs;

void encrypt(char str[], char keyT[5][5], int ps)

int i, a[4];

for (i = 0; i < ps; i += 2) {

search(keyT, str[i], str[i + 1], a);

if (a[0] == a[2]) {

str[i] = keyT[a[0]][mod5(a[1] + 1)];

str[i + 1] = keyT[a[0]][mod5(a[3] + 1)];

else if (a[1] == a[3]) {

str[i] = keyT[mod5(a[0] + 1)][a[1]];

str[i + 1] = keyT[mod5(a[2] + 1)][a[1]];

 }

else {

str[i] = keyT[a[0]][a[3]];

str[i + 1] = keyT[a[2]][a[1]];

void encryptByPlayfairCipher(char str[], char key[])

char ps, ks, keyT[5][5];

// Key

ks = strlen(key);

ks = removeSpaces(key, ks);

toLowerCase(key, ks);

// Plaintext

ps = strlen(str);

toLowerCase(str, ps);

ps = removeSpaces(str, ps);

ps = prepare(str, ps);

generateKeyTable(key, ks, keyT);

encrypt(str, keyT, ps);

}
int main()

char str[SIZE], key[SIZE];

strcpy(key, "Monarchy");

printf("Key text: %s\n", key);

strcpy(str, "instruments");

printf("Plain text: %s\n", str);

encryptByPlayfairCipher(str, key);

printf("Cipher text: %s\n", str);

return 0;

Output:
Key text: Monarchy
Plain text: instruments
Cipher text: gatlmzclrqtx
 Experiment No. 3
IMPLEMENTATION OF HILL CIPHER

AIM:
To implement the hill cipher substitution techniques using C language.

DESCRIPTION:

To Each letter is represented by a number modulo 26. Often the simple

scheme A = 0, B = 1... Z = 25, is used, but this is not an essential feature of
the cipher. To encrypt a message, each block of n letters is multiplied by an
invertible n × n matrix, against modulus 26. To decrypt the message, each
block is multiplied by the inverse of the matrix used for encryption. The
matrix used for encryption is the cipher key, and it should be chosen
randomly from the set of invertible n × n matrices (modulo 26).

EXAMPLE:

ALGORITHM:

STEP-1: Read the plain text and key from the user.
STEP-2: Split the plain text into groups of length three.
STEP-3: Arrange the keyword in a 3*3 matrix.
STEP-4: Multiply the two matrices to obtain the cipher text of length three.
STEP-5: Combine all these groups to get the complete cipher text. 

Solution:
#include<stdio.h>

#include<math.h>
float encrypt[3][1], decrypt[3][1], a[3][3], b[3][3], mes[3][1], c[3][3];

void encryption(); //encrypts the message

void decryption(); //decrypts the message

void getKeyMessage(); //gets key and message from user

void inverse(); //finds inverse of key matrix

void main() {

getKeyMessage();

encryption();

decryption();

void encryption() {

int i, j, k;

for(i = 0; i < 3; i++)

for(j = 0; j < 1; j++)

for(k = 0; k < 3; k++)

encrypt[i][j] = encrypt[i][j] + a[i][k] * mes[k][j];

printf("\nEncrypted string is: ");

for(i = 0; i < 3; i++)

printf("%c", (char)(fmod(encrypt[i][0], 26) + 97));

void decryption() {

int i, j, k;
inverse();

for(i = 0; i < 3; i++)

for(j = 0; j < 1; j++)

for(k = 0; k < 3; k++)

decrypt[i][j] = decrypt[i][j] + b[i][k] * encrypt[k][j];

printf("\nDecrypted string is: ");

for(i = 0; i < 3; i++)

printf("%c", (char)(fmod(decrypt[i][0], 26) + 97));

printf("\n");

void getKeyMessage() {

int i, j;

char msg[3];

printf("Enter 3x3 matrix for key (It should be inversible):\n");

for(i = 0; i < 3; i++)

for(j = 0; j < 3; j++) {

scanf("%f", &a[i][j]);

c[i][j] = a[i][j];

printf("\nEnter a 3 letter string: ");

scanf("%s", msg);

for(i = 0; i < 3; i++)

mes[i][0] = msg[i] - 97;

}
void inverse() {

int i, j, k;

float p, q;

for(i = 0; i < 3; i++)

for(j = 0; j < 3; j++) {

if(i == j)

b[i][j]=1;

else

b[i][j]=0;

for(k = 0; k < 3; k++) {

for(i = 0; i < 3; i++) {

p = c[i][k];

q = c[k][k];

for(j = 0; j < 3; j++) {

if(i != k) {

c[i][j] = c[i][j]*q - p*c[k][j];

b[i][j] = b[i][j]*q - p*b[k][j];

for(i = 0; i < 3; i++)

for(j = 0; j < 3; j++)

b[i][j] = b[i][j] / c[i][i];

printf("\n\nInverse Matrix is:\n");

for(i = 0; i < 3; i++) {

for(j = 0; j < 3; j++)

printf("%d ", b[i][j]);

printf("\n");

Output:
 Experiment No. 4
IMPLEMENTATION OF VIGENERE CIPHER

AIM:
To implement the Vigenere cipher substitution techniques using C
language.

DESCRIPTION:

To encrypt, a table of alphabets can be used, termed a tabula recta,

Vigenère square, or Vigenère table. It consists of the alphabet written out
26 times in different rows, each alphabet shifted cyclically to the left
compared to the prev 26 possible Caesar ciphers. At different points in the
encryption process, the cipher uses a different alphabet from one of the
rows. The alphabet used at each point depends on a repeating keyword.

Each row starts with a key letter. The remainder of the row holds the
letters A to Z. Although there are 26 key rows shown, you will only use as
many keys as there are unique letters in the key string, here just 5 keys, {L,
E, M, O, N}. For successive letters of the message, we are going to take
successive letters of the key string, and encipher each message letter using
its corresponding key row. Choose the next letter of the key, go along that
row to find the column heading that matches the message character; the
letter at the [key-row, msg-col] is the enciphered letter.

EXAMPLE:
ALGORITHM:

STEP-1: Arrange the alphabets in row and column of a 26*26 matrix.

STEP-2: Circulate the alphabets in each row to position left such that the
first letter is
attached to last.
STEP-3: Repeat this process for all 26 rows and construct the final key
matrix.
STEP-4: The keyword and the plain text is read from the user.
STEP-5: The characters in the keyword are repeated sequentially so as to
match with that of the plain text.
STEP-6: Pick the first letter of the plain text and that of the keyword as the
row indices
and column indices respectively.
STEP-7: The junction character where these two meet forms the cipher
character.
STEP-8: Repeat the above steps to generate the entire cipher text.. 

Solution:
#include<stdio.h>

#include<string.h>

int main(){

char msg[] = "THECRAZYPROGRAMMER";

char key[] = "HELLO";

int msgLen = strlen(msg), keyLen = strlen(key), i, j;

char newKey[msgLen], encryptedMsg[msgLen], decryptedMsg[msgLen];

//generating new key

for(i = 0, j = 0; i < msgLen; ++i, ++j){

if(j == keyLen)

j = 0;

newKey[i] = key[j];

newKey[i] = '\0';

//encryption

for(i = 0; i < msgLen; ++i)

encryptedMsg[i] = ((msg[i] + newKey[i]) % 26) + 'A';

encryptedMsg[i] = '\0';

//decryption

for(i = 0; i < msgLen; ++i)

decryptedMsg[i] = (((encryptedMsg[i] - newKey[i]) + 26) % 26) + 'A';

decryptedMsg[i] = '\0';

printf("Original Message: %s", msg);

printf("\nKey: %s", key);

printf("\nNew Generated Key: %s", newKey);

printf("\nEncrypted Message: %s", encryptedMsg);

printf("\nDecrypted Message: %s", decryptedMsg);

return 0;

Output:
Original Message: THECRAZYPROGRAMMER
Key: HELLO
New Generated Key: HELLOHELLOHELLOHEL
Encrypted Message: ALPNFHDJAFVKCLATIC
Decrypted Message: THECRAZYPROGRAMMER
 Experiment No. 5
IMPLEMENTATION OF RAIL FENCE – ROW & COLUMN
TRANSFORMATION TECHNIQUE
AIM:

To write a C program to implement the rail fence transposition technique.

DESCRIPTION:

In the rail fence cipher, the plain text is written downwards and diagonally
on successive "rails" of an imaginary fence, then moving up when we reach
the bottom rail.
When we reach the top rail, the message is written downwards again until
the whole plaintext is written out. The message is then read off in rows.

EXAMPLE 1:

EXAMPLE 2:

ALGORITHM:
STEP-1: Read the Plain text.
STEP-2: Arrange the plain text in row columnar matrix format.
STEP-3: Now read the keyword depending on the number of columns of
the plain text.
STEP-4: Arrange the characters of the keyword in sorted order and the
corresponding
columns of the plain text.
STEP-5: Read the characters row wise or column wise in the former order
to get the
cipher text.

Solution:

#include<stdio.h>

#include<string.h>

void encryptMsg(char msg[], int key){

int msgLen = strlen(msg), i, j, k = -1, row = 0, col = 0;

char railMatrix[key][msgLen];

for(i = 0; i < key; ++i)

for(j = 0; j < msgLen; ++j)

railMatrix[i][j] = '\n';

for(i = 0; i < msgLen; ++i){

railMatrix[row][col++] = msg[i];

if(row == 0 || row == key-1)

k= k * (-1);
 row = row + k;

printf("\nEncrypted Message: ");

for(i = 0; i < key; ++i)

for(j = 0; j < msgLen; ++j)

if(railMatrix[i][j] != '\n')

printf("%c", railMatrix[i][j]);

void decryptMsg(char enMsg[], int key){

int msgLen = strlen(enMsg), i, j, k = -1, row = 0, col = 0, m = 0;

char railMatrix[key][msgLen];

for(i = 0; i < key; ++i)

for(j = 0; j < msgLen; ++j)

railMatrix[i][j] = '\n';

for(i = 0; i < msgLen; ++i){

railMatrix[row][col++] = '*';

if(row == 0 || row == key-1)

k= k * (-1);

row = row + k;
 }

for(i = 0; i < key; ++i)

for(j = 0; j < msgLen; ++j)

if(railMatrix[i][j] == '*')

railMatrix[i][j] = enMsg[m++];

row = col = 0;

k = -1;

printf("\nDecrypted Message: ");

for(i = 0; i < msgLen; ++i){

printf("%c", railMatrix[row][col++]);

if(row == 0 || row == key-1)

k= k * (-1);

row = row + k;

int main(){

char msg[] = "Hello World";

char enMsg[] = "Horel ollWd";

int key = 3;
 printf("Original Message: %s", msg);

encryptMsg(msg, key);

decryptMsg(enMsg, key);

return 0;

Output:
Original Message: Hello World
Encrypted Message: Horel ollWd
Decrypted Message: Hello World
 Experiment No. 6
IMPLEMENTATION OF DATA ENCRYPTION STANDARD (DES) 
AIM:

To write a C program to implement Data Encryption Standard (DES) using

C Language.

DESCRIPTION:

DES is a symmetric encryption system that uses 64-bit blocks, 8 bits of

which are used for parity checks. The key therefore has a "useful" length of
56 bits, which means that only 56 bits are actually used in the algorithm.
The algorithm involves carrying out combinations, substitutions and
permutations between the text to be encrypted and the key, while making
sure the operations can be performed in both directions. The key is
ciphered on 64 bits and made of 16 blocks of 4 bits, generally denoted k to
1

k . Given that "only" 56 bits are actually used for encrypting, there can be
16

2 different keys.
56

The main parts of the algorithm are as follows:

  Fractioning of the text into 64-bit blocks
  Initial permutation of blocks
 Breakdown of the blocks into two parts: left and right, named L and R
  Permutation and substitution steps repeated 16 times
  Re-joining of the left and right parts then inverse initial permutation

EXAMPLE:
ALGORITHM:

STEP-1: Read the 64-bit plain text.

STEP-2: Split it into two 32-bit blocks and store it in two different arrays.
STEP-3: Perform XOR operation between these two arrays.
STEP-4: The output obtained is stored as the second 32-bit sequence and
the original
second 32-bit sequence forms the first part.
STEP-5: Thus the encrypted 64-bit cipher text is obtained in this way.
Repeat the same
process for the remaining plain text characters. 

Solution:
#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <math.h>

#include <time.h>
int IP[] =

58, 50, 42, 34, 26, 18, 10, 2,

60, 52, 44, 36, 28, 20, 12, 4,

62, 54, 46, 38, 30, 22, 14, 6,

64, 56, 48, 40, 32, 24, 16, 8,

57, 49, 41, 33, 25, 17, 9, 1,

59, 51, 43, 35, 27, 19, 11, 3,

61, 53, 45, 37, 29, 21, 13, 5,

63, 55, 47, 39, 31, 23, 15, 7

};

int E[] =

32, 1, 2, 3, 4, 5,

4, 5, 6, 7, 8, 9,

8, 9, 10, 11, 12, 13,

12, 13, 14, 15, 16, 17,

16, 17, 18, 19, 20, 21,

20, 21, 22, 23, 24, 25,

24, 25, 26, 27, 28, 29,

28, 29, 30, 31, 32, 1

};

int P[] =

{
 16, 7, 20, 21,

29, 12, 28, 17,

1, 15, 23, 26,

5, 18, 31, 10,

2, 8, 24, 14,

32, 27, 3, 9,

19, 13, 30, 6,

22, 11, 4, 25

};

int FP[] =

40, 8, 48, 16, 56, 24, 64, 32,

39, 7, 47, 15, 55, 23, 63, 31,

38, 6, 46, 14, 54, 22, 62, 30,

37, 5, 45, 13, 53, 21, 61, 29,

36, 4, 44, 12, 52, 20, 60, 28,

35, 3, 43, 11, 51, 19, 59, 27,

34, 2, 42, 10, 50, 18, 58, 26,

33, 1, 41, 9, 49, 17, 57, 25

};

int S1[4][16] =

14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,

0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,

4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,

 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13

};

int S2[4][16] =

15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,

3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,

0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,

13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9

};

int S3[4][16] =

10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,

13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,

13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,

1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12

};

int S4[4][16] =

7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,

13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,

10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,

3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14

};
int S5[4][16] =

2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,

14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,

4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,

11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3

};

int S6[4][16] =

12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,

10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,

9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,

4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13

};

int S7[4][16]=

4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,

13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,

1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,

6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12

};

int S8[4][16]=

13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,

 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,

7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,

2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11

};

int PC1[] =

57, 49, 41, 33, 25, 17, 9,

1, 58, 50, 42, 34, 26, 18,

10, 2, 59, 51, 43, 35, 27,

19, 11, 3, 60, 52, 44, 36,

63, 55, 47, 39, 31, 23, 15,

7, 62, 54, 46, 38, 30, 22,

14, 6, 61, 53, 45, 37, 29,

21, 13, 5, 28, 20, 12, 4

};

int PC2[] =

14, 17, 11, 24, 1, 5,

3, 28, 15, 6, 21, 10,

23, 19, 12, 4, 26, 8,

16, 7, 27, 20, 13, 2,

41, 52, 31, 37, 47, 55,

30, 40, 51, 45, 33, 48,

44, 49, 39, 56, 34, 53,

46, 42, 50, 36, 29, 32

};

int SHIFTS[] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };

FILE* out;

int LEFT[17][32], RIGHT[17][32];

int IPtext[64];

int EXPtext[48];

int XORtext[48];

int X[8][6];

int X2[32];

int R[32];

int key56bit[56];

int key48bit[17][48];

int CIPHER[64];

int ENCRYPTED[64];

void expansion_function(int pos, int text)

for (int i = 0; i < 48; i++)

if (E[i] == pos + 1) {

EXPtext[i] = text;

}
int initialPermutation(int pos, int text)

int i;

for (i = 0; i < 64; i++)

if (IP[i] == pos + 1) {

break;

IPtext[i] = text;

int F1(int i)

int r, c, b[6];

for (int j = 0; j < 6; j++) {

b[j] = X[i][j];

r = b[0] * 2 + b[5];

c = 8 * b[1] + 4 * b[2] + 2 * b[3] + b[4];

if (i == 0) {

return S1[r][c];

else if (i == 1) {
 return S2[r][c];

else if (i == 2) {

return S3[r][c];

else if (i == 3) {

return S4[r][c];

else if (i == 4) {

return S5[r][c];

else if (i == 5) {

return S6[r][c];

else if (i == 6) {

return S7[r][c];

else if (i == 7) {

return S8[r][c];

int XOR(int a, int b) {

return (a ^ b);

int ToBits(int value)

{

int k, j, m;

static int i;

if (i % 32 == 0) {

i = 0;

for (j = 3; j >= 0; j--)

m = 1 << j;

k = value & m;

if (k == 0) {

X2[3 - j + i] = '0' – 48;

else {

X2[3 - j + i] = '1' – 48;

i = i + 4;

int SBox(int XORtext[])

int k = 0;

for (int i = 0; i < 8; i++)

 {

for (int j = 0; j < 6; j++) {

X[i][j] = XORtext[k++];

int value;

for (int i = 0; i < 8; i++)

value = F1(i);

ToBits(value);

int PBox(int pos, int text)

int i;

for (i = 0; i < 32; i++)

if (P[i] == pos + 1) {

break;

R[i] = text;

void cipher(int Round, int mode)

{

for (int i = 0; i < 32; i++) {

expansion_function(i, RIGHT[Round – 1][i]);

for (int i = 0; i < 48; i++)

if (mode == 0) {

XORtext[i] = XOR(EXPtext[i], key48bit[Round][i]);

else {

XORtext[i] = XOR(EXPtext[i], key48bit[17 – Round][i]);

SBox(XORtext);

for (int i = 0; i < 32; i++) {

PBox(i, X2[i]);

for (int i = 0; i < 32; i++) {

RIGHT[Round][i] = XOR(LEFT[Round – 1][i], R[i]);

void finalPermutation(int pos, int text)

{

int i;

for (i = 0; i < 64; i++)

if (FP[i] == pos + 1) {

break;

ENCRYPTED[i] = text;

void convertToBinary(int n)

int k, m;

for (int i = 7; i >= 0; i--)

m = 1 << i;

k = n & m;

if (k == 0) {

fprintf(out, "0");

else {

fprintf(out, "1");

}
int convertCharToBit(long int n)

FILE* inp = fopen("input.txt", "rb");

out = fopen("bits.txt", "wb+");

char ch;

int i = n * 8;

while (i)

ch = fgetc(inp);

if (ch == -1) {

break;

i--;

convertToBinary(ch);

fclose(out);

fclose(inp);

void Encryption(long int plain[])

out = fopen("cipher.txt", "ab+");

for (int i = 0; i < 64; i++) {

initialPermutation(i, plain[i]);

}
for (int i = 0; i < 32; i++) {

LEFT[0][i] = IPtext[i];

for (int i = 32; i < 64; i++) {

RIGHT[0][i – 32] = IPtext[i];

for (int k = 1; k < 17; k++)

cipher(k, 0);

for (int i = 0; i < 32; i++)

LEFT[k][i] = RIGHT[k – 1][i];

for (int i = 0; i < 64; i++)

if (i < 32) {

CIPHER[i] = RIGHT[16][i];

else {

CIPHER[i] = LEFT[16][i – 32];

finalPermutation(i, CIPHER[i]);

}
 for (int i = 0; i < 64; i++) {

fprintf(out, "%d", ENCRYPTED[i]);

fclose(out);

void Decryption(long int plain[])

out = fopen("decrypted.txt", "ab+");

for (int i = 0; i < 64; i++) {

initialPermutation(i, plain[i]);

for (int i = 0; i < 32; i++) {

LEFT[0][i] = IPtext[i];

for (int i = 32; i < 64; i++) {

RIGHT[0][i – 32] = IPtext[i];

for (int k = 1; k < 17; k++)

cipher(k, 1);

for (int i = 0; i < 32; i++) {

 LEFT[k][i] = RIGHT[k – 1][i];

for (int i = 0; i < 64; i++)

if (i < 32) {

CIPHER[i] = RIGHT[16][i];

} else {

CIPHER[i] = LEFT[16][i – 32];

finalPermutation(i, CIPHER[i]);

for (int i = 0; i < 64; i++) {

fprintf(out, "%d", ENCRYPTED[i]);

fclose(out);

void convertToBits(int ch[])

int value = 0;

for (int i = 7; i >= 0; i--) {

value += (int)pow(2, i) * ch[7 – i];

}
 fprintf(out, "%c", value);

int bittochar()

out = fopen("result.txt", "ab+");

for (int i = 0; i < 64; i = i + 8) {

convertToBits(&ENCRYPTED[i]);

fclose(out);

void key56to48(int round, int pos, int text)

int i;

for (i = 0; i < 56; i++)

if (PC2[i] == pos + 1) {

break;

key48bit[round][i] = text;

int key64to56(int pos, int text)

int i;
 for (i = 0; i < 56; i++)

if (PC1[i] == pos + 1) {

break;

key56bit[i] = text;

void key64to48(unsigned int key[])

int k, backup[17][2];

int CD[17][56];

int C[17][28], D[17][28];

for (int i = 0; i < 64; i++) {

key64to56(i, key[i]);

for (int i = 0; i < 56; i++)

if (i < 28) {

C[0][i] = key56bit[i];

else {

D[0][i – 28] = key56bit[i];

}
}

for (int x = 1; x < 17; x++)

int shift = SHIFTS[x – 1];

for (int i = 0; i < shift; i++) {

backup[x - 1][i] = C[x – 1][i];

for (int i = 0; i < (28 – shift); i++) {

C[x][i] = C[x – 1][i + shift];

k = 0;

for (int i = 28 – shift; i < 28; i++) {

C[x][i] = backup[x – 1][k++];

for (int i = 0; i < shift; i++) {

backup[x - 1][i] = D[x – 1][i];

for (int i = 0; i < (28 – shift); i++) {

D[x][i] = D[x – 1][i + shift];

}
 k = 0;

for (int i = 28 – shift; i < 28; i++) {

D[x][i] = backup[x – 1][k++];

for (int j = 0; j < 17; j++)

for (int i = 0; i < 28; i++) {

CD[j][i] = C[j][i];

for (int i = 28; i < 56; i++) {

CD[j][i] = D[j][i – 28];

for (int j = 1; j < 17; j++)

for (int i = 0; i < 56; i++) {

key56to48(j, i, CD[j][i]);

void decrypt(long int n)

{
 FILE* in = fopen("cipher.txt", "rb");

long int plain[n * 64];

int i = -1;

char ch;

while (!feof(in))

ch = getc(in);

plain[++i] = ch – 48;

for (int i = 0; i < n; i++)

Decryption(plain + i * 64);

bittochar();

fclose(in);

void encrypt(long int n)

FILE* in = fopen("bits.txt", "rb");

long int plain[n * 64];

int i = -1;

char ch;
 while (!feof(in))

ch = getc(in);

plain[++i] = ch – 48;

for (int i = 0; i < n; i++) {

Encryption(plain + 64 * i);

fclose(in);

void create16Keys()

FILE* pt = fopen("key.txt", "rb");

unsigned int key[64];

int i = 0, ch;

while (!feof(pt))

ch = getc(pt);

key[i++] = ch – 48;

key64to48(key);
 fclose(pt);

long int findFileSize()

FILE* inp = fopen("input.txt", "rb");

long int size;

if (fseek(inp, 0L, SEEK_END)) {

perror("fseek() failed");

// size will contain number of chars in the input file.

else {

size = ftell(inp);

fclose(inp);

return size;

int main()

// destroy contents of these files (from previous runs, if any)

out = fopen("result.txt", "wb+");

fclose(out);

out = fopen("decrypted.txt", "wb+");

 fclose(out);

out = fopen("cipher.txt", "wb+");

fclose(out);

create16Keys();

long int n = findFileSize() / 8;

convertCharToBit(n);

encrypt(n);

decrypt(n);

return 0;

Output:
result.txt – IT WILL CONTAIN OUR DECRYPTED TEXT.

TEMP FILES:

bits.txt – IT WILL CONTAIN OUR PLAIN TEXT CONVERTED IN BITS.

cipher.txt – IT WILL CONTAIN OUR ENCRYPTED TEXT IN BITS.
decrypted.txt – IT WILL CONTAIN OUR DECRYPTED TEXT IN BITS (SAME AS bits.txt IN
CONTENT)