AJAY KUMAR GARG ENGINEERING COLLEGE

DEPARTMENT OF INFORMATION TECHNOLOGY

CNS Lab
(KIT 751A)

Submitted To Submitted By

Ms. Mrignainy Kansal Vishal Mishra

2000270130189
 INDEX

S.No. Title Date Remarks

Write a C program that contains a string (char pointer) with

1
the value ‘Hello world’. The program should XOR each
character in this string with 0 and display the result.

Write a C program that contains a string (char pointer) with

a value ‘Hello world’. The program should AND or and
2 XOR each character in this string with 127 and display the
result.
Write a Java program to perform encryption and decryption
using the following algorithms
3
a. Ceaser cipher
b. Substitution cipher
c. Hill Cipher

4 Write a C/JAVA program to implement the DES algorithm

logic.

5 Write a C/JAVA program to implement the Blowfish

algorithm logic.

6 Write a C/JAVA program to implement the Rijndael algorithm

logic.
 Using Java Cryptography, encrypt the text “Hello World” using
BlowFish. Create your own key using Java keytool.
7

Write a Java program to implement RSA Algorithm

Implement the Diffie-Hellman Key Exchange mechanism 9 using

HTML and JavaScript. Consider the end user as one of 21-22 the
9 parties (Alice) and the JavaScript application as other party
(bob).
Calculate the message digest of a text using the SHA-1 23-24
algorithm in JAVA.
10
 Program :1
AIM: Write a C program that contains a string (char pointer) with a value \Hello World’. The
program should XOR each character in this string with 0 and display the result.

PROGRAM:

#include<stdlib.h> main()
{
char str[]="Hello World"; char str1[11];
int i,len; len=strlen(str); for(i=0;i<len;i++)
{
str1[i]=str[i]^0; printf("%c",str1[i]);
}
printf("\n");
}

OUTPUT:
Hello World
Hello World
 Program :2

AIM: Write a C program that contains a string (char pointer) with a value \Hello World’. The
program should AND or and XOR each character in this string with 127 and display the
result.

PROGRAM:

#include<stdio.h>
#include<stdlib.h>
void main()
{
char str[]="Hello World";
char str1[11];
char str2[11]=str[];
int i,len;
len = strlen(str);
for(i=0;i<len;i++)
{
str1[i] = str[i]&127;
printf("%c",str1[i]);
}
printf("\n");
for(i=0;i<len;i++)
{
str3[i] = str2[i]^127;
printf("%c",str3[i]);
}
printf("\n");
}

Output:
Hello World
Hello World
Hello World
 Program : 3

AIM: Write a Java program to perform encryption and decryption using the following
algorithms:

● Ceaser Cipher
● Substitution Cipher
● Hill Cipher

PROGRAM:

Ceaser Cipher

import java.io.BufferedReader; import java.io.IOException;

import java.io.InputStreamReader; import java.util.Scanner;
public class CeaserCipher {

static Scanner sc=new Scanner(System.in);

static BufferedReader br = new BufferedReader(new
InputStreamReader(System.in)); public static void main(String[]
args) throws IOException {
// TODO code application logic here

System.out.print("Enter any String: "); String str =

br.readLine();
System.out.print("\nEnter the Key: "); int key
= sc.nextInt();

String encrypted = encrypt(str, key);

System.out.println("\nEncrypted String is: " +encrypted);
String decrypted = decrypt(encrypted, key);
System.out.println("\nDecrypted String is: "
+decrypted); System.out.println("\n");
}
public static String encrypt(String str, int key)

{
String encrypted="";
For(int i=0; i<str.length(); i++)
{

int c=str.charAt(i);
if (Character.isUpperCase(c)) {
c = c + (key % 26);

if (c > 'Z')

c = c - 26;

else if (Character.isLowerCase(c)) { c = c + (key % 26);

if (c > 'z')

c = c - 26;

encrypted += (char) c;
}
return encrypted;
}

public static String decrypt(String str, int key)

{ String decrypted = ""; for(int i
= 0; i < str.length(); i++) { int c = str.charAt(i);
if (Character.isUpperCase(c)) {
c = c - (key % 26);
if (c < 'A')
c = c + 26;
}

else if (Character.isLowerCase(c)) { c = c - (key % 26);

if (c < 'a')

}
c = c + 26;

OUTPUT:
Enter any String: Hello World
Enter the Key: 5
Encrypted String is: MjqqtBtwqi
Decrypted String is: Hello World
Substitution Cipher

PROGRAM:

import java.io.*; import java.util.*;

public class SubstitutionCipher {
static Scanner sc = new Scanner(System.in);
static BufferedReader br = new BufferedReader(new
InputStreamReader(System.in)); public static void main(String[]
args) throws IOException {
/ TODO code application logic here String a
= "abcdefghijklmnopqrstuvwxyz"; String b =
"zyxwvutsrqponmlkjihgfedcba";
System.out.print("Enter any string: "); String str =
br.readLine();
String decrypt = ""; char c;
for(int i=0;i<str.length();i++)
{
c = str.charAt(i); int j = a.indexOf(c);
decrypt = decrypt+b.charAt(j);
}
System.out.println("The encrypted data is: " +decrypt);
}
}

OUTPUT:
Enter any string: aceho
The encrypted data is: zxvsl
Hill Cipher

PROGRAM:

import java.io.*;
import java.util.*;
import java.io.*;
public class HillCipher {
static float[][] decrypt = new float[3][1];
static float[][] a = new float[3][3];
static float[][] b = new float[3][3];
static float[][] mes = new float[3][1];
static float[][] res = new float[3][1];
static BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) throws IOException {
/ TODO code application logic here getkeymes();
for(int i=0;i<3;i++)
for(int j=0;j<1;j++)
for(int k=0;k<3;k++) {
res[i][j]=res[i][j]+a[i] [k]*mes[k][j];
}
System.out.print("\nEncrypted string is : ");
for(int i=0;i<3;i++)
{ System.out.print((char)(res[i] [0]%26+97));
res[i][0]=res[i][0];
}
inverse();

for(int i=0;i<3;i++)
for(int j=0;j<1;j++)
for(int k=0;k<3;k++) {

decrypt[i][j] = decrypt[i][j]+b[i][k]*res[k][j]; }
System.out.print("\nDecrypted string is : ");
for(int i=0;i<3;i++){
System.out.print((char)(decrypt[i] [0]% 26+97));
}

System.out.print("\n");
}
public static void getkeymes() throws IOException {
System.out.println("Enter 3x3 matrix for key (It should be
inversible): ");
for(int i=0;i<3;i++) for(int j=0;j<3;j++) a[i][j]= sc.nextFloat();
System.out.print("\nEnter a 3 letter string: ");
String msg = r.readLine();
for(int i=0;i<3;i++)
mes[i][0] = msg.charAt(i)-97;
}
public static void inverse()
{ floatp,q;
float[][] c = a; for(int i=0;i<3;i++) for(int j=0;j<3;j++) {
//a[i][j]=sc.nextFloat();
if(i==j) b[i][j]=1;
else b[i][j]=0;
}
for(int k=0;k<3;k++)
{ for(int i=0;i<3;i++) {
p = c[i][k];
q = c[k][k];
for(int 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(int i=0;i<3;i++)
for(int j=0;j<3;j++)

{ b[i][j] = b[i][j]/c[i][i]; }
System.out.println(""); System.out.println("\nInverse Matrix is :
"); for(int i=0;i<3;i++) {
for(int j=0;j<3;j++) System.out.print(b[i][j] + " ");
System.out.print("\n"); }
} }
OUTPUT:
Enter a 3 letter string: hai
Encrypted string is :fdx
Inverse Matrix is :
0.083333336 0.41666666 -0.33333334
-0.41666666 -0.083333336 0.6666667
0.5833333 -0.083333336 -0.33333334
Decrypted string is: hai
 Program : 4

AIM: Write a Java program to implement the DES algorithm logic.

PROGRAM:

import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.security.spec.KeySpec;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
public class DES {
private static final String UNICODE_FORMAT = "UTF8";
public static final String DESEDE_ENCRYPTION_SCHEME = "DESede";
privateKeySpecmyKeySpec;
privateSecretKeyFactorymySecretKeyFactory;
private Cipher cipher;
byte[] keyAsBytes;
private String myEncryptionKey;
private String myEncryptionScheme;
SecretKey key;
static BufferedReader br = new BufferedReader(new
InputStreamReader(System.in)); public DES() throws Exception {
/ TODO code application logic here myEncryptionKey

= "ThisIsSecretEncryptionKey"; myEncryptionScheme =
DESEDE_ENCRYPTION_SCHEME; keyAsBytes =
myEncryptionKey.getBytes(UNICODE_FORMAT); myKeySpec
= new DESedeKeySpec(keyAsBytes);
mySecretKeyFactory =
SecretKeyFactory.getInstance(myEncryptionScheme); cipher =
Cipher.getInstance(myEncryptionScheme);
key = mySecretKeyFactory.generateSecret(myKeySpec);
}
public String encrypt(String unencryptedString)

{ String encryptedString = null;

try {
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] plainText = unencryptedString.getBytes(UNICODE_FORMAT);
byte[] encryptedText = cipher.doFinal(plainText);
BASE64Encoder base64encoder = new BASE64Encoder(); encryptedString
= base64encoder.encode(encryptedText); } catch (Exception )
{ e.printStackTrace(); } returnencryptedString; }
public String decrypt(String encryptedString)
{ String decryptedText=null;
try {
cipher.init(Cipher.DECRYPT_MODE, key);
BASE64Decoder base64decoder = new BASE64Decoder(); byte[]
encryptedText = base64decoder.decodeBuffer(encryptedString);
byte[] plainText = cipher.doFinal(encryptedText); decryptedText=
bytes2String(plainText); }
catch (Exception e)
{ e.printStackTrace(); }
returndecryptedText; }
private static String bytes2String(byte[] bytes)
{
StringBufferstringBuffer = new StringBuffer();
for (int i = 0; i <bytes.length; i++) {
stringBuffer.append((char) bytes[i]);
} returnstringBuffer.toString();
}
public static void main(String args []) throws Exception

{ System.out.print("Enter the string: ");

DES myEncryptor= new DES();
String stringToEncrypt = br.readLine();
String encrypted = myEncryptor.encrypt(stringToEncrypt);
String decrypted = myEncryptor.decrypt(encrypted);
System.out.println("\nString To Encrypt: " +stringToEncrypt);
System.out.println("\nEncrypted Value : "+encrypted);
System.out.println("\nDecrypted Value : " +decrypted);
System.out.println("");

OUTPUT:
Enter the string: Welcome
String To Encrypt: Welcome
Encrypted Value : BPQMwc0wKvg=
Decrypted Value : Welcome
 Program: 5

AIM: Write a C program to implement the BlowFish algorithm logic.

PROGRAM:

import java.io.*;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.security.Key;

import javax.crypto.Cipher;

import javax.crypto.CipherOutputStream;

import javax.crypto.KeyGenerator;

import sun.misc.BASE64Encoder;

public class BlowFish { public static void main(String[] args) throws

Exception {

// TODO code application logic here

KeyGeneratorkeyGenerator = KeyGenerator.getInstance("Blowfish");
keyGenerator.init(128); Key secretKey = keyGenerator.generateKey();
Cipher cipherOut = Cipher.getInstance("Blowfish/CFB/NoPadding");
cipherOut.init(Cipher.ENCRYPT_MODE, secretKey);

BASE64Encoder encoder = new BASE64Encoder();

byte iv[] = cipherOut.getIV();

if (iv != null) { System.out.println("Initialization Vector of the

Cipher: " + encoder.encode(iv));

FileInputStream fin = new FileInputStream("inputFile.txt");

FileOutputStreamfout = new FileOutputStream("outputFile.txt");
CipherOutputStreamcout = new CipherOutputStream(fout, cipherOut);

int input = 0;

while ((input = fin.read()) != -1) { }

fin.close(); cout.close(); } }
OUTPUT:
Initialization Vector of the Cipher: dI1MXzW97oQ=
Contents of inputFile.txt: Hello World
Contents of outputFile.txt: ùJÖÞ NåI<
 Program: 6

AIM: Write a C/JAVA program to implement the Rijndael algorithm logic.

PROGRAM:

import java.security.*; import javax.crypto.*; import

javax.crypto.spec.*; import java.io.*;
public class AES {
public static String asHex (byte buf[]) { StringBuffer
strbuf = new StringBuffer(buf.length * 2); int i; for (i=
0; i < buf.length; i++) { if (((int) buf[i] & 0xff)
<0x10)strbuf.append("0");
strbuf.append(Long.toString((int) buf[i] & 0xff, 16)); }
return strbuf.toString(); }
public static void main(String[] args) throws Exception
{ String message="AES still rocks!!";

// Get the KeyGenerator

KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128); // 192 and 256 bits may not be available
// Generate the secret key specs. SecretKey skey =
kgen.generateKey(); byte[] raw = skey.getEncoded();
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
// Instantiate the cipher
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
byte[] encrypted = cipher.doFinal((args.length == 0 ?
message : args[0]).getBytes());
System.out.println("encrypted string: " +
asHex(encrypted)); cipher.init(Cipher.DECRYPT_MODE,
skeySpec); byte[] original = cipher.doFinal(encrypted);
String originalString = new String(original);
System.out.println("Original string: " + originalString + " " +
asHex(original));

}
OUTPUT:

Input your message: Hello

KGRCET Encrypted text:
3ooo&&(*&*4r4 Decrypted
text: Hello KGRCET