Shad_Cryptography_PracticalFile_IT_4th_Year (1).docx

Practical File
Of
Cryptography
Dr Ram Manohar Lohia Awadh University
Ayodhya.
In the partial fulfillment of the requirement for the award of the degree of
Bachelor of Technology(IT)
2018-2022
Submitted To:
Er. Awadhesh Maurya
Submitted By:
Sonu Kumar Maurya
B.Tech 7th Sem IT
Roll No: 18350
1

INDEX
SNO NAME OF PRACTICLE SIGNATURE
1 To implement the simple s substitution technique
named Caesar cipher using g C language.
2
To write a C programto implement the Playfair
Substitution technique
3 To write a C program to implement the hill cipher
substitution technique.
4 To write a C program to implement the rail fence
transposition technique
5
To write a C program to implement Data Encryption
Standard (DES) using C Language.
6
To write a C program to implement the RSA
encryption algorithm.
7 To implement the Diffie-Hellman Key Exchange
algorithm using C language.
8 To write a C program to implement the MD5 hashing
technique.
9 To write a Python program to implement the SHA
Algorithm.
10 To write a C program to implement the
monoalphabetic cipher substitution technique.
11 To write a C program to implement the Columnar
cipher transposition technique.

PRACTICAL-1
IMPLEMENTATION OF CAESAR CIPHER
OBJECTIVE:
To implement the simple s substitution technique named Caesar cipher using g 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 c an think of the 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:
user.
ALGORITHM:
STEP-1: Read the
plain text from the
user.
STEP-2: Read the
key value from the
STEP-3: If the key is positive then encrypt the text by adding the key with each
character in the p lain text.
STEP-4: Else subtract the key from the plain text.
STEP-5: Display the cipher text obtained above.
PROGRAM: (Caesar Cipher)
#include<stdio.h>

#include<string.h>
#include<conio.h>
#include<ctype.h>
void main()
{ char plain[10],
cipher[10]; int
key,i,length;
int result;
clrscr();
printf("n Enter the plaintext:");
scanf("%s", plain); printf("n Enter
the key value:"); scanf("%d", &key);
printf("n n t PLAIN TEXt: %s",plain);
printf("n n t ENCRYPTED TEXT: ");
for(i = 0, length = strlen(plain); i < length; i++)
{
cipher[i]=plain[i] + key;
if (isupper(plain[i]) && (cipher[i] > 'Z'))
cipher[i] = cipher[i] - 26;
if (islower(plain[i]) && (cipher[i] >'z'))
cipher[i] = cipher[i] - 26;
printf("%c", cipher[i]);
}
printf("n n t AFTER DECRYPTION : ");
for(i=0;i<length;i++)
{
plain[i]=cipher[i]-key;
if(isupper(cipher[i])&&(plain[i]<'A'))
plain[i]=plain[i]+26;
if(islower(cipher[i])&&(plain[i]<'a'))
plain[i]=plain[i]+26; printf("%c",plain[i]);
} getch();
}
OUTPUT:

RESULT:
Thus the implementation of Caesar cipher had been executed successfully.

PRACTICAL-2
OBJECTIVE:
IMPLEMENTATION OF PLAYFAIR CIPHER
To write a C program to implement the Playfair Substitution technique.
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 diagrams (groups of 2
letters) such that, for example, "HelloWorld" becomes "HE LL OW OR LD", 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.
PROGRAM: (Playfair Cipher)
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<ctype.h> #define
MX 5
void playfair(char ch1,char ch2, char key[MX][MX])
{ int i,j,w,x,y,z;
FILE *out;
if((out=fopen("cipher.txt","a+"))==NULL)
{ printf("File Currupted.");
}
for(i=0;i<MX;i++)
{ for(j=0;j<MX;j++)
{
if(ch1==key[i][j])
{ w=i;
x=j;
}
else if(ch2==key[i][j])
{ y=i;
z=j;
}}}
//printf("%d%d %d%d",w,x,y,z); if(w==y)
{ x=(x+1)%5;z=(z+1)%5;
printf("%c%c",key[w][x],key[y][z]); fprintf(out,
"%c%c",key[w][x],key[y][z]);
} else
if(x==z)
{

w=(w+1)%5;y=(y+1)%5;
printf("%c%c",key[w][x],key[y][z]); fprintf(out,
"%c%c",key[w][x],key[y][z]);
} else
{
printf("%c%c",key[w][z],key[y][x]);
fprintf(out, "%c%c",key[w][z],key[y][x]);
}
fclose(out);
} void
main()
{ int i,j,k=0,l,m=0,n;
char key[MX][MX],keyminus[25],keystr[10],str[25]={0};
char
alpa[26]={'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'}
; clrscr();
printf("nEnter
key:"); gets(keystr);
printf("nEnter the plain text:"); gets(str);
n=strlen(keystr);
//convert the characters to
uppertext for (i=0; i<n;
i++)
{
if(keystr[i]=='j')
keystr[i]='i';
else
if(keystr[i]=='J')keystr[i]='I';
keystr[i] = toupper(keystr[i]);
}
//convert all the characters of plaintext to uppertext
for (i=0; i<strlen(str); i++)
{
if(str[i]=='j')
str[i]='i'; else
if(str[i]=='J')
str[i]='I';
str[i] = toupper(str[i]);
} j=0;
for(i=0;i<26;i++)
{ for(k=0;k<n;k++)
{
if(keystr[k]==alpa[i]) break;
else if(alpa[i]=='J')
break; }
if(k==n) {
keyminus[j]=alpa[i];j++;
}
}

//construct key keymatrix k=0;
for(i=0;i<MX;i++)
{ for(j=0;j<MX;j++)
{ if(k<n)
{
key[i][j]=keystr[k];
k++;} else {
key[i][j]=keyminus[m];m++;
}
printf("%c ",key[i][j]);
} printf("n");
}
printf("nnEntered text :%snCipher Text
:",str); for(i=0;i<strlen(str);i++) {
if(str[i]=='J')str[i]='I';
if(str[i+1]=='0')
playfair(str[i],'X',key);
else
{ if(str[i+1]=='J')str[i+1]='I';
if(str[i]==str[i+1])
playfair(str[i],'X',key); else
{
playfair(str[i],str[i+1],key);i++;
}}
} getch();
}
OUTPUT:
RESULT:
Thus the Playfair cipher substitution technique had been implemented successfully.

PRACTICAL-3
IMPLEM ENTATION OF HILL CIPHER OBJECTIVE:
To write a C program to implement the hill cipher substitution techniques.
DESCRIPTION:
Each letter is represented by a number modulo 26. Often the simple scheme A = 0, B
= 1... Z = 25, is used, but this i s 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 t wo matrices to obtain the cipher text of length three.
STEP-5: Combine all these groups to get the complete cipher text.

PROGRAM: (Hill Cipher)
#include<stdio.h>
#include<conio.h>
#include<string.h>
int main(){
unsigned int a[3][3]={{6,24,1},{13,16,10},{20,17,15}};
unsigned int b[3][3]={{8,5,10},{21,8,21},{21,12,8}};
int i,j, t=0; unsigned int c[20],d[20]; char
msg[20]; clrscr();
printf("Enter plain textn ");
scanf("%s",msg);
for(i=0;i<strlen(msg);i++)
{ c[i]=msg[i]-65;
printf("%d ",c[i]);
}
for(i=0;i<3;i++)
{ t=0; for(j=0;j<3;j++)
{ t=t+(a[i][j]*c[j]);
} d[i]=t%26;
} printf("nEncrypted Cipher
Text :"); for(i=0;i<3;i++) printf("
%c",d[i]+65); for(i=0;i<3;i++)
{ t=0;
for(j=0;j<3;j++)
{ t=t+(b[i][j]*d[j]);
} c[i]=t%26;
}
printf("nDecrypted Cipher Text :");
for(i=0;i<3;i++) printf("
%c",c[i]+65); getch(); return 0;
}
OUTPUT:
RESULT:
Thus the hill cipher substitution technique had been implemented successfully in C.

PRACTICAL-4
IMPLEMENTATION OF RAIL FENCE – ROW & COLUMN
TRANSFORMATION TECHNIQUE
OBJECTIVE:
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:
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.

PROGRAM: (Rail Fence)
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{ int i,j,k,l; char
a[20],c[20],d[20];
clrscr();
printf("ntt RAIL FENCE TECHNIQUE");
printf("nnEnter the input string : ");
gets(a);
l=strlen(a);
/*Ciphering*/ for(i=0,j=0;i<l;i++)
{ if(i%2==0)
c[j++]=a[i]
;
}
for(i=0;i<l;i++)
{ if(i%2==1)
c[j++]=a[i]
;
}
c[j]='0';
printf("nCipher text after applying rail fence
:"); printf("n%s",c);
/*Deciphering*/
if(l%2==0)
k=l/2;
else k=(l/2)+1;
for(i=0,j=0;i<k;i++)
{ d[j]=c[i];
j=j+2; }
for(i=k,j=1;i<l;i++)
{ d[j]=c[i];
j=j+2; }
d[l]='0';
printf("nText after decryption : ");
printf("%s",d); getch();
}
OUTPUT:

RESULT:
Thus the rail fence algorithm had been executed successfully.

PRACTICAL-5
IMPLEMENTATION OF DES
OBJECTIVE:
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 k1 to k16. Given that "only"
56 bits are actually used for encrypting, there can be 256
different keys.
The main parts of the algorithm are as follows:
• Fractioning of the text into 64bit
• 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.
PROGRAM:
DES.java
import javax.swing.*; import
java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey; import
javax.crypto.spec.SecretKeySpec;
import java.util.Random ; class DES {
byte[] skey = new byte[1000]; String
skeyString; static byte[] raw;
String inputMessage,encryptedData,decryptedMessage;
public DES()
{ try
{ generateSymmetricKey();
inputMessage=JOptionPane.showInputDialog(null,"Enter
message to encrypt");
byte[] ibyte = inputMessage.getBytes();
byte[] ebyte=encrypt(raw, ibyte); String
encryptedData = new String(ebyte);
System.out.println("Encrypted message "+encryptedData);
JOptionPane.showMessageDialog(null,"Encrypted Data
"+"n"+encryptedData);
byte[] dbyte= decrypt(raw,ebyte);
String decryptedMessage = new String(dbyte);
System.out.println("Decrypted message
"+decryptedMessage);
JOptionPane.showMessageDialog(null,"Decrypted Data
"+"n"+decryptedMessage);
}
catch(Exception e)
{
System.out.println(e);
}
}
void generateSymmetricKey() { try
{

Random r = new Random(); int num
= r.nextInt(10000); String knum =
String.valueOf(num); byte[] knumb
= knum.getBytes();
skey=getRawKey(knumb); skeyString
= new String(skey);
System.out.println("DES Symmetric key = "+skeyString);
}
catch(Exception e)
{
System.out.println(e);
}
}
private static byte[] getRawKey(byte[] seed) throws Exception
{
KeyGenerator kgen = KeyGenerator.getInstance("DES");
SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
sr.setSeed(seed);
kgen.init(56, sr);
SecretKey skey = kgen.generateKey();
raw = skey.getEncoded(); return
raw;
}
private static byte[] encrypt(byte[] raw, byte[] clear)
throws Exception {
SecretKeySpec skeySpec = new
SecretKeySpec(raw, "DES");
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE,
skeySpec); byte[] encrypted =
cipher.doFinal(clear); return encrypted;
}
private static byte[] decrypt(byte[] raw, byte[] encrypted)
throws Exception
{
SecretKeySpec skeySpec = new
SecretKeySpec(raw, "DES");
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.DECRYPT_MODE, skeySpec);
byte[] decrypted =
cipher.doFinal(encrypted); return decrypted;
}
public static void main(String args[])
{ DES des = new DES();
}
}
OUTPUT:

Shad_Cryptography_PracticalFile_IT_4th_Year (1).docx

RESULT:
Thus the data encryption standard algorithm had been implemented successfully
using C language.

PRACTICAL-6
IMPLEMENTATION OF RSA
OBJECTIVE:
To write a C program to implement the RSA encryption algorithm.
DESCRIPTION:
RSA is an algorithm used by modern computers to encrypt and decrypt messages. It
is an asymmetric cryptographic algorithm. Asymmetric means that there are two different
keys. This is also called public key cryptography, because one of them can be given to
everyone. A basic principle behind RSA is the observation that it is practical to find three
very large positive integers e, d and n such that with modular exponentiation for all integer
m:
(me
)d
= m (mod n)
The public key is represented by the integers n and e; and, the private key, by the
integer d. m represents the message. RSA involves a public key and a private key. The public
key can be known by everyone and is used for encrypting messages. The intention is that
messages encrypted with the public key can only be decrypted in a reasonable amount of time
using the private key.
EXAMPLE:
ALGORITHM:
STEP-1: Select two co-prime numbers as p and q.
STEP-2: Compute n as the product of p and q.
STEP-3: Compute (p-1)*(q-1) and store it in z.
STEP-4: Select a random prime number e that is less than that of z.
STEP-5: Compute the private key, d as e * mod-1
(z).
STEP-6: The cipher text is computed as messagee
* mod n.

STEP-7: Decryption is done as cipherd
mod n.
PROGRAM: (RSA)
#include<stdio.h>
#include<conio.h>
#include<stdlib.h> #include<math.h>
#include<string.h>
long int
p,q,n,t,flag,e[100],d[100],temp[100],j,m[100],en[100],i
; char msg[100]; int prime(long int); void ce(); long
int cd(long int); void encrypt(); void decrypt();
void main()
{ clrscr();
printf("nENTER FIRST PRIME NUMBERn");
scanf("%d",&p); flag=prime(p);
if(flag==0)
{ printf("nWRONG INPUTn");
getch(); }
printf("nENTER ANOTHER PRIME NUMBERn");
scanf("%d",&q); flag=prime(q);
if(flag==0||p==q)
{ printf("nWRONG
INPUTn"); getch(); }
printf("nENTER MESSAGEn");
fflush(stdin);
scanf("%s",msg);
for(i=0;msg[i]!=NULL;i++)
m[i]=msg[i]; n=p*q;
t=(p-1)*(q-1); ce();

printf("nPOSSIBLE VALUES OF e AND d AREn");
for(i=0;i<j-1;i++)
printf("n%ldt%ld",e[i],d[i]);
encrypt();
decrypt();
getch();
}
int prime(long int pr)
{ int i;
j=sqrt(pr);
for(i=2;i<=j;i++
)
{ if(pr%i==0)
return 0; }
return 1; }
void ce() { int
k; k=0;
for(i=2;i<t;i++
)
{ if(t%i==0) continue;
flag=prime(i);
if(flag==1&&i!=p&&i!=q
)
{ e[k]=i;
flag=cd(e[k])
; if(flag>0)
{ d[k]=flag;
k++; }
if(k==99)
break; } } }
long int cd(long int x)
{ long int k=1; while(1) {
k=k+t; if(k%x==0)
return(k/x); } } void
encrypt() { long int
pt,ct,key=e[0],k,len; i=0;
len=strlen(msg);
while(i!=len) {
pt=m[i]; pt=pt-
96;
k=1;
for(j=0;j<key;j++)
{ k=k*pt;
k=k%n;
} temp[i]=k;
ct=k+96;
en[i]=ct;
i++;
}
en[i]=-1;
printf("nTHE ENCRYPTED
MESSAGE ISn");
for(i=0;en[i]!=-1;i++)
printf("%c",en[i]); } void
decrypt()

{
long int
pt,ct,key=d[0],k; i=0;
while(en[i]!=-1) {
ct=temp[i]; k=1;
for(j=0;j<key;j++) {
k=k*ct; k=k%n; }
pt=k+96; m[i]=pt; i++;
}
m[i]=-1;
printf("nTHE DECRYPTED MESSAGE
ISn"); for(i=0;m[i]!=-1;i++)
printf("%c",m[i]);
}
OUTPUT:
RESULT:
Thus the C program to implement RSA encryption technique had been implemented
successfully

PRACTICAL-7
IMPLEMENTATION OF DIFFIE HELLMAN KEY EXCHANGE
ALGORITHM
OBJECTIVE:
To implement the Diffie-Hellman Key Exchange algorithm using C language.
DESCRIPTION:
Diffie– Hellman Key Exchange establishes a shared secret between two parties that
can be used for secret communication for exchanging data over a public network. It is
primarily used as a method of exchanging cryptography keys for use in symmetric encryption
algorithms like AES. The algorithm in itself is very simple. The process begins by having the
two parties, Alice and Bob. Let's assume that Alice wants to establish a shared secret with
Bob.
EXAMPLE:
ALGORITHM:
STEP-1: Both Alice and
Bob shares the same public
keys g and p.
STEP-2: Alice selects a random
public key a.
STEP-3: Alice computes his secret key A as ga
mod p.
STEP-5: Similarly Bob also selects a public key b and computes his secret key as B
and sends the same back to Alice.

STEP-6: Now both of them compute their common secret key asthe other one’ s secret
key power of a mod p.
PROGRAM: (Diffie Hellman Key Exchange)
#include<stdio.h> #include<conio.h>
long long int power(int a, int b, int mod)
{
long long int t;
if(b==1) return a;
t=power(a,b/2,mod);
if(b%2==0) return
(t*t)%mod;
else
return (((t*t)%mod)*a)%mod;
}
long int calculateKey(int a, int x, int n)
{
return power(a,x,n);
}
void main()
{
int n,g,x,a,y,b;
clrscr();
printf("Enter the value of n and g : ");
scanf("%d%d",&n,&g); printf("Enter the value of x for the
first person : "); scanf("%d",&x); a=power(g,x,n);
printf("Enter the value of y for the second person : ");
scanf("%d",&y); b=power(g,y,n); printf("key for the
first person is :
%lldn",power(b,x,n)); printf("key for
the second person is :
%lldn",power(a,y,n)); getch();
}
OUTPUT:

RESULT:
Thus the Diffie-Hellman key exchange algorithm had been successfully implemented
using C.

PRACTICAL-8 IM PLEMENTATION OF MD5
OBJECTIVE:
To write a C program to implement the MD5 hashing technique.
DESCRIPTION:
MD5 processes a variable-length message into a fixed-length output of 128 bits. The
input message is broken up into chunks of 512-bit blocks. The message is padded so that its
length is divisible by 512. The padding works as follows: first a single bit, 1, is appended to
the end of the message. This is followed by as many zeros as are required to b ring the length
of the message up to 64 bits less than a multiple of 512. The remaining bits are filled up with
64 bits representing the length of the original message, modulo 264
.The main M D5 algorithm
operates on a 128-bit state, divided into four 32-bit words, denoted A, B, C, and D. These are
initialized to certain fixed constants. The main algorithm then uses each 512-bit message
block in turn to modify the state .
EXAMPLE:
ALGORITHM:
STEP-1: Read the 128-bit plain text.
STEP-2: Divide into four blocks of 32-
bits named as A, B, C and D.
STEP-3: Compute the
functions f, g, h
and i with operations
such as, rotations,
permutations,
etc,.
STEP-4: The output of these functions are combined together as F and performed
circular shifting and then given to key round.
STEP-5: Finally, right shift of ‘ s’ times are performed and the results are combined
together to produce the final output.

PROGRAM:( MD5)
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include<conio.h> typedef
union uwb
{
unsigned w; unsigned char b[4];
} MD5union; typedef unsigned
DigestArray[4];
unsigned func0( unsigned abcd[] ){
return ( abcd[1] & abcd[2]) | (~abcd[1] &
abcd[3]);} unsigned func1( unsigned abcd[] ){
return ( abcd[3] & abcd[1]) | (~abcd[3] &
abcd[2]);} unsigned func2( unsigned abcd[] ){
return abcd[1] ^ abcd[2] ^ abcd[3];}
unsigned func3( unsigned abcd[] ){ return
abcd[2] ^ (abcd[1] |~ abcd[3]);} typedef
unsigned (*DgstFctn)(unsigned a[]); unsigned
*calctable( unsigned *k)
{
double s, pwr; int
i;
pwr = pow( 2, 32); for
(i=0; i<64; i++)
{
s = fabs(sin(1+i)); k[i] =
(unsigned)( s * pwr );
} return
k;
}
unsigned rol( unsigned r, short N )
{
unsigned mask1 = (1<<N) -1; return ((r>>(32-N)) & mask1)
| ((r<<N) & ~mask1);
}
unsigned *md5( const char *msg, int mlen)
{
static DigestArray h0 = { 0x67452301, 0xEFCDAB89,
0x98BADCFE, 0x10325476 }; static DgstFctn ff[] = {
&func0, &func1, &func2, &func3}; static short M[] = {
1, 5,3,7}; static short O[] = { 0, 1,5,0}; static short
rot0[] = { 7,12,17,22}; static short rot1[] = { 5,
9,14,20}; static short rot2[] = { 4,11,16,23}; static
short rot3[] = { 6,10,15,21};
static short *rots[] = {rot0, rot1, rot2, rot3 };
static unsigned kspace[64]; static unsigned *k;
static DigestArray h;
DigestArray abcd;
DgstFctn fctn; short m,

o, g; unsigned f;
short *rotn; union
{
unsigned w[16]; char b[64];
}mm; int os = 0;
int grp, grps, q, p; unsigned char *msg2;
if (k==NULL) k= calctable(kspace); for (q=0; q<4;
q++) h[q] = h0[q]; // initialize
{
grps = 1 + (mlen+8)/64; msg2 = malloc(
64*grps); memcpy( msg2, msg, mlen);
msg2[mlen] = (unsigned char)0x80;
q = mlen + 1;
while (q < 64*grps){ msg2[q] = 0; q++ ;
} {
MD5union u;
u.w = 8*mlen; q -= 8;
memcpy(msg2+q, &u.w, 4 );
}
}
for (grp=0; grp<grps; grp++)
{
memcpy( mm.b, msg2+os, 64);
for(q=0;q<4;q++) abcd[q] = h[q]; for (p
= 0; p<4; p++)
{
fctn = ff[p]; rotn = rots[p];
m = M[p]; o= O[p]; for (q=0; q<16;
q++)
{
g = (m*q + o) % 16;
f = abcd[1] + rol( abcd[0]+ fctn(abcd)+k[q+16*p]
+ mm.w[g], rotn[q%4]);
abcd[0] = abcd[3]; abcd[3] = abcd[2];
abcd[2] = abcd[1]; abcd[1] = f;
}}
for (p=0; p<4; p++)
h[p] += abcd[p]; os +=
64;
}
return h;}
void main()
{
int j,k;
const char *msg = "The quick brown fox jumps
over the lazy dog";
unsigned *d = md5(msg, strlen(msg));
MD5union u;
clrscr();

printf("t MD5 ENCRYPTION ALGORITHM IN C
nn"); printf("Input String to be Encrypted using
MD5 : nt%s",msg); printf("nnThe MD5 code for input string
is: n"); printf("t= 0x"); for (j=0;j<4; j++){ u.w = d[j];
for (k=0;k<4;k++) printf("%02x",u.b[k]);
}
printf("n");
printf("nt MD5 Encyption Successfully
Completed!!!nn"); getch();
system("pause");
getch();}
OUTPUT:
RESULT:
Thus the implementation of MD5 hashing algorithm had been implemented successfully using
C.

PRACTICAL-9
IMPLEMENTATION OF SHA1
OBJECTIVE:
To write a C program to implement the Monoalphabetic cipher.
DESCRIPTION:
SHA ( Secure Hash Algorithms ) are setof cryptographichashfunctionsdefinedbythe language
to be usedforvariousapplicationssuchaspassword security etc. Some variantsof itare supported
by Pythoninthe “hashlib”library.These canbe foundusing“algorithms_guaranteed”functionof
hashlib
To proceed with, letsfirstdiscuss the functions goingtobe usedinthisarticle.
Functionsassociated:
encode() :Convertsthe stringintobytestobe acceptable byhashfunction.
hexdigest() :Returns the encodeddatainhexadecimal format.
SHA Hash
The differentSHA hashfunctions are explainedbelow.
SHA256 : Thishashfunction belongtohashclassSHA-2, the internal block size of itis32 bits.
SHA384 : Thishashfunction belongtohashclassSHA-2, the internal block size of itis32 bits. Thisis
one of the truncated version.
SHA224 : Thishashfunction belongtohashclassSHA-2, the internal block size of itis32 bits. Thisis
one of the truncated version.
SHA512 : Thishashfunction belongtohashclassSHA-2, the internal block size of itis64 bits.
SHA1 : The 160 bit hashfunctionthatresemblesMD5hash inworkingandwas discontinuedtobe
usedseeingitssecurity vulnerabilities.
PROGRAM:
importhashlib
# initializingstring
str = "GeeksforGeeks"
# encodingGeeksforGeeksusingencode()
# thensendingtoSHA256()
result=hashlib.sha256(str.encode())
# printingthe equivalenthexadecimal value.
print("The hexadecimal equivalentof SHA256is: ")

print(result.hexdigest())
print("r")
print("r")
print("r")
# encodingGeeksforGeeks usingencode()

print("r")
print("The hexadecimal equivalentof SHA1is:")
Output:

PRACTICAL-10
IMPLEMENTATION OF Monoalphabetic Cipher
OBJECTIVE:
To write a C program to implement the Monoalphabetic cipher.
DESCRIPTION:
Better than Caesar Cipher.
If, instead the “cipher” line can be any permutation of the key 26 alphabetic characters, then there
are 26! Or greater than 4 * 1026
possible keys. This is 10 orders of magnitude greater than the key
space for DES and would seem to as a Mono-alphabetic substitution cipher, because a single cipher
alphabet is used per message.
There is however, another line of attack. If one analytically knows the nature of the plain text, then
the analyst can exploit the regularities of the language.
Example
For each character of alphabet, assign different-abrupt concerned character.
Plain text: goodmorning
Cipher text: TLLWNLIMRMT
Limitations
Monoalphabetic ciphers are easy to break because they reflect the frequency data of the
original alphabet.
A countermeasure is to provide multiple substitutes, known as homophones, for a single
letter.

PROGRAM:
//MONOALPHABATIC CIPHER
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
char
pt[26]={'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'}; char
ct[26]={'Z','Y','X','W','V','U','T','S','R','Q','P','O','N','M','L','K','J','I','H','G','F','E','D','C','B','
A'}; char p[20]={'0'},c[20]={'0'},r[20]={'0'}; int i,j; clrscr();
printf("n enter the plain text:"); gets(p);
//converting plain text into cipher text (encryption)
for(i=0;i<strlen(p);i++)
{
for(j=0;j<26;j++)
{
if(pt[j]==p[i])
{
c[i]=ct[j];
}
}
}
printf("n cipher text is: %s",c);
//converting cipher text into plain text (decryption)
for(i=0;i<strlen(c);i++)
{
for(j=0;j<26;j++)
{
if(ct[j]==c[i])
{
r[i]=pt[j];
}
}
}
printf("n n plain text is: %s",r);
getch();
}
Output:

PRACTICAL-11
IMPLEMENTATION OF CLUMNAR CIPHER
OBJECTIVE:
To implement the simple s transposition technique named columnar cipher using g C
language.
DESCRIPTION:
The ColumnarTranspositionCipherisaform of transpositioncipherjustlikeRail Fence
Cipher. ColumnarTransposition involves writingthe plaintextoutinrows, andthenreading
the ciphertextoff incolumns one byone.
Encryption
Ina transposition cipher, the orderof the alphabetsisre-arrangedtoobtainthe cipher-text.
1. The message iswrittenoutinrowsof a fixedlength, andthenreadoutagaincolumn by
column,and the columnsare choseninsome scrambled order.
2. Widthof the rows andthe permutation of the columns are usually definedbyakeyword.
3. For example, the wordHACK isof length
4 (sothe rows are of length4),and the permutationisdefinedbythe alphabetical orderof
the lettersinthe keyword. Inthiscase, the orderwould be “3 1 2 4”.
4. Any spare spacesare filledwithnullsorleftblankorplacedbyacharacter (Example:_).
5. Finally, the message isreadoff incolumns, inthe orderspecified bythe keyword.
To decipher it, the recipient has to work out the column lengths by dividing the message
length by the key length.
Then, write the message out in columns again, then re-order the columns by reforming the
key word.
PROGRAM
#include<stdio.h>
#include<conio.h>
void main()
{

Decryption
int
i,j,k[5],count=0,istop,jstop,stop,flag=0,plen,mod,devid
e; char p[100],p1[5][20],newm[5][20],e[100],d[100];
clrscr(); printf("Enter plain text::::::"); gets(p);
for(i=0;i<20;i
++) {
for(j=0;j<5;j+
+)
{ if(p[count]!=32&&p[count]!='0')
p1[i][j]=p[count++];
else if(p[count]==32)
count++;
else
{istop=i;jstop
=j; flag=1;
break;
}
}
if(flag==1)
break;
}
flag=0;
for(i=0;i<20;i
++) {
printf("n");
if(i==istop)
{stop=jstop;
flag=1;
}

else
stop=5;
for(j=0;j<stop;j++)
{printf("%c",p1[i][j]);
}
if(flag==1)
break;
}
p1[i][j]
='0';
plen=istop*5+jstop;
//printf("%d",plen);
printf("n ENTER KEY (NUMBER OF 5 COLOUMNS BETWEEN 1TO5)");
for(i=0;i<5;i++)
scanf("%d",&k[i]);
//ENCRYPTION
PART::::::::::::::::::::::::::::::::::::::::::::::: count=0;
for(i=0;i<5;i++) { for(j=0;j<20;j++)
{ if(p1[j][k[i]-
1]!='0')
{e[count]=p1[j][k[i]-
1];
e[count+1]='0';
count++;
}
else
break;
}
}
printf("n ENCRYPTED TEXT::::::::::::");
for(i=0;i<plen;i++)
printf("%c",e[i]);
//DECRTYPTION PART:::::::::::::::
devide=plen/5;
mod=plen%5;
count=0;
for(i=0;i<5;i++) {
printf("n");
for(j=0;j<devide+1;j
++)
{

if(j==devide&&k[i]>mod
) newm[j][i]='0';
else
newm[j][i]=e[count++
];
}
}
for(i=0;i<devide+1;i++)
{ printf("n");
for(j=0;j<5;j++)
{
printf("%c",newm[i][j]);
}
}
count=0;
for(i=0;i<devide+1;i++)
{
for(j=0;j<5;j++)
{ if(newm[i][k[j]-
1]!='0')
{d[count]=newm[i][k[j]-
1]; d[count+1]='0';
count++;
}
}
}
d[count]='0'; printf("n
DECRYPTED TEXT:::::::");
for(i=0;i<plen;i++)
printf("%c",d[i]);
//printf("%d",'0');
getch();
}
OUTPUT:

Shad_Cryptography_PracticalFile_IT_4th_Year (1).docx

More Related Content

Similar to Shad_Cryptography_PracticalFile_IT_4th_Year (1).docx (20)

Recently uploaded (20)

Shad_Cryptography_PracticalFile_IT_4th_Year (1).docx