NAME: CHANDRAKANTH G REG NO: 710719104023

Ex. No: 1(a)

ENCRYPTION AND DECRYPTION USING CEASER CIPHER
Date:

AIM:

To encrypt and decrypt the given message by using Ceaser Cipher encryption algorithm.

ALGORITHM:

STEP 1: In Ceaser Cipher each letter in the plaintext is replaced by a letter some fixed number of
positions down the alphabet.
STEP 2: For example, with a left shift of 3, D would be replaced by A, E would become B, and so on.
STEP 3: The encryption can also be represented using modular arithmetic by first transforming the
letters into numbers, according to the scheme, A = 0, B = 1, Z = 25.
STEP 4: Encryption of a letter x by a shift n can be described mathematically as,
En(x) = (x + n) mod26
STEP 5: Decryption is performed similarly,
Dn (x)=(x - n) mod26

PROGRAM CODING:
class caesarCipher {
public static String encode(String enc, int offset) {
offset = offset % 26 + 26;
StringBuilder encoded = new StringBuilder();
for (char i : enc.toCharArray()) {
if (Character.isLetter(i)) {
if (Character.isUpperCase(i)) {
encoded.append((char) ('A' + (i - 'A' + offset) % 26));
} else {
encoded.append((char) ('a' + (i - 'a' + offset) % 26));
}
} else {
encoded.append(i);
}
}
return encoded.toString();
}

public static String decode(String enc, int offset) {

return encode(enc, 26 - offset);
}
NAME: CHANDRAKANTH G REG NO: 710719104023

public static void main(String[] args) throws java.lang.Exception {

String msg = "Anna University";
System.out.println("Simulating Caesar Cipher\n------------------------");
System.out.println("Input : " + msg);
System.out.printf("Encrypted Message : ");
System.out.println(caesarCipher.encode(msg, 3));
System.out.printf("Decrypted Message : ");
System.out.println(caesarCipher.decode(caesarCipher.encode(msg, 3), 3));
}
}

OUTPUT:

DEPT OF CSE
PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)

OUTPUT & RESULT (30)

POSTVIVA (5)
NAME: CHANDRAKANTH G REG NO: 710719104023

TOTAL (100)

FACULTY SIGN

RESULT:
Thus the program for ceaser cipher encryption and decryption algorithm has been implemented and the
output verified successfully.
Ex. No : 1(b)
PLAYFAIR CIPHER
Date :

AIM:
To implement a program to encrypt a plain text and decrypt a cipher text using play fair Cipher
substitution technique.

ALGORITHM:
STEP 1: To encrypt a message, one would break the message into digrams (groups of 2 letters)
STEP 2: For example, "HelloWorld" becomes "HE LL OW OR LD".
STEP 3: These diagrams will be substituted using the key table.
STEP 4: Since encryption requires pairs of letters, messages with an odd number of characters usually
append an uncommon letter, such as "X", to complete the final digram.
STEP 5: The two letters of the diagram are considered opposite corners of a rectangle in the key table.
To perform the substitution, apply the 4 rules, in order, to each pair of letters in the plaintext.

PROGRAM CODING:
import java.awt.Point;
class playfairCipher {
private static char[][] charTable;
private static Point[] positions;

private static String prepareText(String s, boolean chgJtoI) {

s = s.toUpperCase().replaceAll("[^A-Z]", "");
return chgJtoI ? s.replace("J", "I") : s.replace("Q", "");
}

private static void createTbl(String key, boolean chgJtoI) {

NAME: CHANDRAKANTH G REG NO: 710719104023

charTable = new char[5][5];

positions = new Point[26];
String s = prepareText(key + "ABCDEFGHIJKLMNOPQRSTUVWXYZ", chgJtoI);
int len = s.length();
for (int i = 0, k = 0; i < len; i++) {
char c = s.charAt(i);

if (positions[c - 'A'] == null) {

charTable[k / 5][k % 5] = c;
positions[c - 'A'] = new Point(k % 5, k / 5);
k++;
}
}
}

private static String codec(StringBuilder txt, int dir) {

int len = txt.length();
for (int i = 0; i < len; i += 2) {
char a = txt.charAt(i);
char b = txt.charAt(i + 1);
int row1 = positions[a - 'A'].y;
int row2 = positions[b - 'A'].y;
int col1 = positions[a - 'A'].x;
int col2 = positions[b - 'A'].x;
if (row1 == row2) {
col1 = (col1 + dir) % 5;
col2 = (col2 + dir) % 5;
} else if (col1 == col2) {

row1 = (row1 + dir) % 5;

row2 = (row2 + dir) % 5;
} else {
int tmp = col1;
col1 = col2;
col2 = tmp;
}
txt.setCharAt(i, charTable[row1][col1]);
txt.setCharAt(i + 1, charTable[row2][col2]);
}
return txt.toString();
}

private static String encode(String s) {

StringBuilder sb = new StringBuilder(s);
for (int i = 0; i < sb.length(); i += 2) {
if (i == sb.length() - 1) {
NAME: CHANDRAKANTH G REG NO: 710719104023

sb.append(sb.length() % 2 == 1 ? 'X' : "");

} else if (sb.charAt(i) == sb.charAt(i + 1)) {
sb.insert(i + 1, 'X');
}
}
return codec(sb, 1);
}

private static String decode(String s) {

return codec(new StringBuilder(s), 4);
}

public static void main(String[] args) throws java.lang.Exception {

String key = "CSE";
String txt = "Security Lab"; /* make sure string length is even */ /* change J to I */
boolean chgJtoI = true;
createTbl(key, chgJtoI);
String enc = encode(prepareText(txt, chgJtoI));
System.out.println("Simulating Playfair Cipher\n----------------------");
System.out.println("Input Message : " + txt);
System.out.println("Encrypted Message : " + enc);
System.out.println("Decrypted Message : " + decode(enc));
}
}

OUTPUT:
 NAME: CHANDRAKANTH G REG NO: 710719104023

DEPT OF CSE
PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)

OUTPUT & RESULT (30)

POSTVIVA (5)

TOTAL (100)

FACULTY SIGN

RESULT:
Thus the program for playfair cipher encryption and decryption algorithm has been implemented and the
output verified successfully.

Ex. No : 1(c)
HILL CIPHER
Date:

AIM:
To implement a program to encrypt and decrypt using the Hill cipher substitution technique

ALGORITHM:
STEP 1: In the Hill cipher Each letter is represented by a number modulo 26.
STEP 2: To encrypt a message, each block of n letters is multiplied by an invertible n x n matrix, again
modulus 26.
STEP 3: To decrypt the message, each block is multiplied by the inverse of the matrix used for
encryption.
NAME: CHANDRAKANTH G REG NO: 710719104023

STEP 4: 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).
STEP 5: The cipher can, be adapted to an alphabet with any number of letters.
STEP 6: All arithmetic just needs to be done modulo the number of letters instead of modulo 26.

PROGRAM:
class hillCipher {
/* 3x3 key matrix for 3 characters at once */
public static int[][] keymat = new int[][] { { 1, 2, 1 }, { 2, 3, 2 },
{ 2, 2, 1 } }; /* key inverse matrix */
public static int[][] invkeymat = new int[][] { { -1, 0, 1 }, { 2, -1, 0 }, { -2, 2, -1 } };
public static String key = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

private static String encode(char a, char b, char c) {

String ret = "";
int x, y, z;
int posa = (int) a - 65;
int posb = (int) b - 65;
int posc = (int) c - 65;
x = posa * keymat[0][0] + posb * keymat[1][0] + posc * keymat[2][0];
y = posa * keymat[0][1] + posb * keymat[1][1] + posc * keymat[2][1];
z = posa * keymat[0][2] + posb * keymat[1][2] + posc * keymat[2][2];
a = key.charAt(x % 26);
b = key.charAt(y % 26);
c = key.charAt(z % 26);
ret = "" + a + b + c;
return ret;
}

private static String decode(char a, char b, char c) {

String ret = "";
int x, y, z;
int posa = (int) a - 65;
int posb = (int) b - 65;
int posc = (int) c - 65;
x = posa * invkeymat[0][0] + posb * invkeymat[1][0] + posc * invkeymat[2][0];
y = posa * invkeymat[0][1] + posb * invkeymat[1][1] + posc * invkeymat[2][1];
z = posa * invkeymat[0][2] + posb * invkeymat[1][2] + posc * invkeymat[2][2];
a = key.charAt((x % 26 < 0) ? (26 + x % 26) : (x % 26));

b = key.charAt((y % 26 < 0) ? (26 + y % 26) : (y % 26));

c = key.charAt((z % 26 < 0) ? (26 + z % 26) : (z % 26));
ret = "" + a + b + c;
return ret;
}
NAME: CHANDRAKANTH G REG NO: 710719104023

public static void main(String[] args) throws java.lang.Exception {

String msg;
String enc = "";
String dec = "";
int n;
msg = ("SecurityLaboratory");
System.out.println("simulation of Hill Cipher\n-------------------------");
System.out.println("Input message : " + msg);
msg = msg.toUpperCase();
msg = msg.replaceAll("\\s", "");
/* remove spaces */ n = msg.length() % 3;
/* append padding text X */ if (n != 0) {
for (int i = 1; i <= (3 - n); i++) {
msg += 'X';
}
}
System.out.println("padded message : " + msg);
char[] pdchars = msg.toCharArray();
for (int i = 0; i < msg.length(); i += 3) {
enc += encode(pdchars[i], pdchars[i + 1], pdchars[i + 2]);
}
System.out.println("encoded message : " + enc);
char[] dechars = enc.toCharArray();
for (int i = 0; i < enc.length(); i += 3) {
dec += decode(dechars[i], dechars[i + 1], dechars[i + 2]);
}
System.out.println("decoded message : " + dec);
}
}

OUTPUT:
NAME: CHANDRAKANTH G REG NO: 710719104023

DEPT OF CSE

PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)

OUTPUT & RESULT (30)

POSTVIVA (5)

TOTAL (100)

FACULTY SIGN

RESULT:
Thus the program for hill cipher encryption and decryption algorithm has been implemented and the
output verified successfully.
NAME: CHANDRAKANTH G REG NO: 710719104023

Ex. No : 1(d)
VIGENERE CIPHER
Date:

AIM:
To implement a program for encryption and decryption using vigenere cipher substitution
technique

ALGORITHM:
STEP 1: The Vigenere cipher is a method of encrypting alphabetic text by using a series of different
Caesar ciphers based on the letters of a keyword.
STEP 2: It is a simple form of polyalphabetic substitution.
STEP 3: To encrypt, a table of alphabets can be used, termed a Vigenere square, or Vigenere table.
STEP 4: It consists of the alphabet written out 26 times in different rows, each alphabet shifted
cyclically to the left compared to the previous alphabet, corresponding to the 26 possible Caesar ciphers.
STEP 5: At different points in the encryption process, the cipher uses a different alphabet from one of
the rows used.
STEP 6: The alphabet at each point depends on a repeating keyword.

PROGRAM CODING:
public class vigenereCipher {
static String encode(String text, final String key) {
String res = "";
text = text.toUpperCase();
for (int i = 0, j = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (c < 'A' || c > 'Z') {
continue;
}
res += (char) ((c + key.charAt(j) - 2 * 'A') % 26 + 'A');
j = ++j % key.length();
}
return res;
}

static String decode(String text, final String key) {

String res = "";
text = text.toUpperCase();
for (int i = 0, j = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (c < 'A' || c > 'Z') {
continue;
}
res += (char) ((c - key.charAt(j) + 26) % 26 + 'A');
NAME: CHANDRAKANTH G REG NO: 710719104023

j = ++j % key.length();
}
return res;
}

public static void main(String[] args) throws java.lang.Exception {

String key = "VIGENERECIPHER";
String msg = "SecurityLaboratory";
System.out.println("Simulating Vigenere Cipher\n------------------------");
System.out.println("Input Message : " + msg);
String enc = encode(msg, key);
System.out.println("Encrypted Message : " + enc);
System.out.println("Decrypted Message : " + decode(enc, key));
}
}

OUTPUT:

DEPT OF CSE
PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)

OUTPUT & RESULT (30)

POSTVIVA (5)

TOTAL (100)

FACULTY SIGN
NAME: CHANDRAKANTH G REG NO: 710719104023

RESULT:
Thus the program for vigenere cipher encryption and decryption algorithm has been implemented and
the output verified successfully.
Ex. No : 2(a)
RAIL FENCE CIPHER TRANSPOSITION TECHNIQUE
Date:

AIM:
To implement a program for encryption and decryption using rail fence transposition technique.

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

PROGRAM CODING:
class railfenceCipherHelper
{
int depth;
String encode(String msg, int depth) throws Exception {
int r = depth;
int l = msg.length();
int c = l / depth;
int k = 0;
char mat[][] = new char[r][c];
String enc = "";
for (int i = 0; i < c; i++) {
for (int j = 0; j < r; j++) {
if (k != l) {
mat[j][i] = msg.charAt(k++);
} else {
mat[j][i] = 'X';
NAME: CHANDRAKANTH G REG NO: 710719104023

}
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
enc += mat[i][j];
}
}
return enc;
}

String decode(String encmsg, int depth) throws Exception {

int r = depth;
int l = encmsg.length();
int c = l / depth;
int k = 0;
char mat[][] = new char[r][c];
String dec = "";
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
mat[i][j] = encmsg.charAt(k++);
}
}
for (int i = 0; i < c; i++) {
for (int j = 0; j < r; j++) {
dec += mat[j][i];
}
}
return dec;
}
}

class railFenceCipher {
public static void main(String[] args) throws java.lang.Exception {
railfenceCipherHelper rf = new railfenceCipherHelper();
String msg, enc, dec;
msg = "Anna University, Chennai";
int depth = 2;
enc = rf.encode(msg, depth);
dec = rf.decode(enc, depth);
System.out.println("Simulating Railfence Cipher\n-------------------------");
System.out.println("Input Message : " + msg);
System.out.println("Encrypted Message : " + enc);
System.out.printf("Decrypted Message : " + dec);
}
}
NAME: CHANDRAKANTH G REG NO: 710719104023

OUTPUT:
NAME: CHANDRAKANTH G REG NO: 710719104023

DEPT OF CSE
PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)

OUTPUT & RESULT (30)

POSTVIVA (5)

TOTAL (100)

FACULTY SIGN

RESULT:
Thus the java program for Rail Fence Transposition Technique has been implemented and the output
verified successfully.
Ex. No : 2(b)
ROW AND COLUMN TRANSFORMATION TECHNIQUE
Date:

AIM:
To implement a program for encryption and decryption by using row and column transformation
technique.

ALGORITHM:
STEP 1: Consider the plain text hello world, and let us apply the simple columnar transposition
technique as shown below

h e l l
o w o r
l d
NAME: CHANDRAKANTH G REG NO: 710719104023

STEP 2: The plain text characters are placed horizontally and the cipher text is created with vertical
format as: holewdlo lr.
STEP 3: Now, the receiver has to use the same table to decrypt the cipher text to plain text.

PROGRAM CODING:
import java.util.*;
class TransCipher {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
System.out.println(“Enter the plain text”);
String pl = sc.nextLine();
sc.close();
String s = “”;
int start = 0;
for (int I = 0; I < pl.length(); i++) {
if (pl.charAt(i) == ‘ ‘) {
s = s + pl.substring(start, i);
start = I + 1;
}
}
s = s + pl.substring(start);
System.out.print(s);
System.out.println();
// end of space deletion

int k = s.length();
int l = 0;
int col = 4;
int row = s.length() / col;
char ch[][] = new char[row][col];
for (int I = 0; I < row; i++) {
for (int j = 0; j < col; j++) {
if (l < k) {
ch[i][j] = s.charAt(l);
l++;
} else {
ch[i][j] = ‘#’;
}
}
}
NAME: CHANDRAKANTH G REG NO: 710719104023

// arranged in matrix

char trans[][] = new char[col][row];

for (int I = 0; I < row; i++) {
for (int j = 0; j < col; j++) {
trans[j][i] = ch[i][j];
}
}

for (int I = 0; I < col; i++) {

for (int j = 0; j < row; j++) {
System.out.print(trans[i][j]);
}
}
// display
System.out.println();
}
}

OUTPUT:
 NAME: CHANDRAKANTH G REG NO: 710719104023

DEPT OF CSE
PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)

OUTPUT & RESULT (30)

POSTVIVA (5)

TOTAL (100)

FACULTY SIGN

RESULT:
Thus the java program for Row and Column Transposition Technique has been implemented and the
output verified successfully.
Ex. No : 3
DATA ENCRYPTION STANDARD (DES) ALGORITHM
Date:
NAME: CHANDRAKANTH G REG NO: 710719104023

(USER MESSAGE ENCRYPTION)

AIM:
To use Data Encryption Standard (DES) Algorithm for a practical application like User Message
Encryption.

ALGORITHM:
STEP 1: Create a DES Key.
STEP 2: Create a Cipher instance from Cipher class, specify the following information and separated by
a slash (/).
a. Algorithm name
b. Mode (optional)
c. Padding scheme (optional)
STEP 3: Convert String into Byte[] array format.
STEP 4: Make Cipher in encrypt mode, and encrypt it with Cipher.doFinal() method.
STEP 5: Make Cipher in decrypt mode, and decrypt it with Cipher.doFinal() method.

PROGRAM CODING:
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class DES

{
public static void main(String[] argv) {

try{
System.out.println(“Message Encryption Using DES Algorithm\n-------");
KeyGenerator keygenerator = KeyGenerator.getInstance(“DES”);
SecretKey myDesKey = keygenerator.generateKey();
Cipher desCipher;
desCipher = Cipher.getInstance(“DES/ECB/PKCS5Padding”);
desCipher.init(Cipher.ENCRYPT_MODE, myDesKey);
byte[] text = “Secret Information “.getBytes();
System.out.println(“Message [Byte Format] : “ + text);
NAME: CHANDRAKANTH G REG NO: 710719104023

System.out.println(“Message : “ + new String(text));

byte[] textEncrypted = desCipher.doFinal(text);
System.out.println(“Encrypted Message: “ + textEncrypted);
desCipher.init(Cipher.DECRYPT_MODE, myDesKey);
byte[] textDecrypted = desCipher.doFinal(textEncrypted);
System.out.println(“Decrypted Message: “ + new String(textDecrypted));

}catch(NoSuchAlgorithmException e){
e.printStackTrace();
}catch(NoSuchPaddingException e){
e.printStackTrace();
}catch(InvalidKeyException e){
e.printStackTrace();
}catch(IllegalBlockSizeException e){
e.printStackTrace();
}catch(BadPaddingException e){
e.printStackTrace();
}

}
}

OUTPUT:
NAME: CHANDRAKANTH G REG NO: 710719104023

DEPT OF CSE
PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)

OUTPUT & RESULT (30)

POSTVIVA (5)

TOTAL (100)

FACULTY SIGN
NAME: CHANDRAKANTH G REG NO: 710719104023

RESULT:
Thus the java program for DES Algorithm has been implemented and the output verified successfully.

Ex. No : 4 ADVANCED ENCRYPTION STANDARD (DES) ALGORITHM

Date: ( URL ENCRYPTION )

AIM:
To use Advanced Encryption Standard (AES) Algorithm for a practical application like URL
Encryption.

ALGORITHM:
STEP 1:AES is based on a design principle known as a substitution–permutation.
STEP 2:AES does not use a Feistel network like DES, it uses variant of Rijndael.
STEP 3:It has a fixed block size of 128 bits, and a key size of 128, 192, or 256 bits.
STEP 4:AES operates on a 4 × 4 column-major order array of bytes, termed the state

PROGRAM CODING:
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class AES {

private static SecretKeySpec secretKey;

private static byte[] key;
NAME: CHANDRAKANTH G REG NO: 710719104023

public static void setKey(String myKey) {

MessageDigest sha = null;
try {
key = myKey.getBytes("UTF-8");
sha = MessageDigest.getInstance("SHA-1");
key = sha.digest(key);
key = Arrays.copyOf(key, 16);
secretKey = new SecretKeySpec(key, "AES");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}

public static String encrypt(String strToEncrypt, String secret) {

try {
setKey(secret);
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
return Base64.getEncoder().encodeToString(cipher.doFinal(strToEncrypt.getBytes("UTF-8")));
} catch (Exception e) {
System.out.println("Error while encrypting: " + e.toString());
}
return null;
}

public static String decrypt(String strToDecrypt, String secret) {

try {
setKey(secret);
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5PADDING");
cipher.init(Cipher.DECRYPT_MODE, secretKey);
return new String(cipher.doFinal(Base64.getDecoder().decode(strToDecrypt)));
} catch (Exception e) {
System.out.println("Error while decrypting: " + e.toString());
}
return null;
}

public static void main(String[] args) {

NAME: CHANDRAKANTH G REG NO: 710719104023

final String secretKey = "annaUniversity";

String originalString = "www.annauniv.edu";

String encryptedString = AES.encrypt(originalString, secretKey);
String decryptedString = AES.decrypt(encryptedString, secretKey);

System.out.println("URL Encryption Using AES Algorithm\n------------");

System.out.println("Original URL : " + originalString);
System.out.println("Encrypted URL : " + encryptedString);
System.out.println("Decrypted URL : " + decryptedString);
}
}

OUTPUT:

DEPT OF CSE
NAME: CHANDRAKANTH G REG NO: 710719104023

PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)

OUTPUT & RESULT (30)

POSTVIVA (5)

TOTAL (100)

FACULTY SIGN

RESULT:
Thus the java program for AES Algorithm has been implemented for URL Encryption and the output
verified successfully.
Ex. No : 5
RSA ALGORITHM
Date :

AIM:
To implement RSA (Rivest–Shamir–Adleman) algorithm by using HTML and Javascript.

ALGORITHM:
STEP 1:Choose two prime number p and q
STEP 2:Compute the value of n and p
STEP 3:Find the value of e (public key)
STEP 4:Compute the value of d (private key) using gcd()
STEP 5:Do the encryption and decryption
a. Encryption is given as,
c = te mod n
b. Decryption is given as,
t = cd mod n
NAME: CHANDRAKANTH G REG NO: 710719104023

PROGRAM CODING:
rsa.html
<html>

<head>
<title>RSA Encryption</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>

<body>
<center>
<h1>RSA Algorithm</h1>
<h2>Implemented Using HTML & Javascript</h2>
<hr>
<table>
<tr>
<td>Enter First Prime Number:</td>
<td><input type="number" value="53" id="p"></td>
</tr>
<tr>
<td>Enter Second Prime Number:</td>
<td><input type="number" value="59" id="q"></p>
</td>
</tr>
<tr>
<td>Enter the Message(cipher text):<br>[A=1, B=2,...]</td>
<td><input type="number" value="89" id="msg"></p>
</td>
</tr>
<tr>
<td>Public Key:</td>
<td>
<p id="publickey"></p>
</td>
</tr>
<tr>
<td>Exponent:</td>
<td>
<p id="exponent"></p>
</td>
</tr>
<tr>
<td>Private Key:</td>
<td>
<p id="privatekey"></p>
</td>
NAME: CHANDRAKANTH G REG NO: 710719104023

</tr>
<tr>
<td>Cipher Text:</td>
<td>
<p id="ciphertext"></p>
</td>
</tr>
<tr>
<td><button onclick="RSA();">Apply RSA</button></td>
</tr>
</table>
</center>
</body>
<script type="text/javascript">
function RSA() {
var gcd, p, q, no, n, t, e, i, x;
gcd = function (a, b) { return (!b) ? a : gcd(b, a % b); };
p = document.getElementById('p').value;
q = document.getElementById('q').value;
no = document.getElementById('msg').value;
n = p * q;
t = (p - 1) * (q - 1);

for (e = 2; e < t; e++) {

if (gcd(e, t) == 1) {
break;
}
}

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

x=1+i*t
if (x % e == 0) {
d = x / e;
break;
}
}

ctt = Math.pow(no, e).toFixed(0);

ct = ctt % n;

dtt = Math.pow(ct, d).toFixed(0);

dt = dtt % n;

document.getElementById('publickey').innerHTML = n;
document.getElementById('exponent').innerHTML = e;
document.getElementById('privatekey').innerHTML = d;
NAME: CHANDRAKANTH G REG NO: 710719104023

document.getElementById('ciphertext').innerHTML = ct;
}
</script>
</html>

OUTPUT:

DEPT OF CSE
PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)
NAME: CHANDRAKANTH G REG NO: 710719104023

OUTPUT & RESULT (30)

POSTVIVA (5)

TOTAL (100)

FACULTY SIGN

RESULT:
Thus the RSA algorithm has been implemented using HTML & CSS and the output has been verified
successfully.
Ex. No : 6
DIFFIE-HELLMAN KEY EXCHANGE ALGORITHM
Date:
NAME: CHANDRAKANTH G REG NO: 710719104023

AIM:
To implement the Diffie-Hellman Key Exchange algorithm for a given problem .

ALGORITHM:

STEP 1: Alice and Bob publicly agree to use a modulus p = 23 and base g = 5 (which is a primitive root
modulo 23).

STEP 2: Alice chooses a secret integer a = 4, then sends Bob A = ga mod p

o A = 54 mod 23 = 4

STEP 3: Bob chooses a secret integer b = 3, then sends Alice B = gb mod p

o B = 53 mod 23 = 10

STEP 4: Alice computes s = Ba mod p

o s = 104 mod 23 = 18

STEP 5: Bob computes s = Ab mod p

o s = 43 mod 23 = 18

STEP 6:Alice and Bob now share a secret (the number 18).

PROGRAM CODING:
class DiffieHellman {
public static void main (String args[]) {
int p = 23; /* publicly known (prime number) */
int g = 5; /* publicly known (primitive root) */
int x = 4; /* only Alice knows this secret */
int y = 3; /* only Bob knows this secret */
double aliceSends = (Math.pow(g, x)) % p;
double bobComputes = (Math.pow(aliceSends, y)) % p;
double bobSends = (Math.pow(g, y)) % p;
double aliceComputes = (Math.pow(bobSends, x)) % p;
double sharedSecret = (Math.pow(g, (x * y))) % p;
System.out.println("simulation of Diffie-Hellman key exchange algorithm\
n---------------------------------------------");
System.out.println("Alice Sends : " + aliceSends);
System.out.println("Bob Computes : " + bobComputes);
System.out.println("Bob Sends : " + bobSends);
System.out.println("Alice Computes : " + aliceComputes);
NAME: CHANDRAKANTH G REG NO: 710719104023

System.out.println("Shared Secret : " + sharedSecret);

/* shared secrets should match and equality is transitive */
if ((aliceComputes == sharedSecret) && (aliceComputes == bobComputes))
System.out.println("Success: Shared Secrets Matches! " + sharedSecret);
else
System.out.println("Error: Shared Secrets does not Match");
}
}

OUTPUT:
NAME: CHANDRAKANTH G REG NO: 710719104023

DEPT OF CSE
PREVIVA (5)

AIM &ALGORITHM (30)

PROGRAM (30)

OUTPUT & RESULT (30)

POSTVIVA (5)

TOTAL (100)

FACULTY SIGN
NAME: CHANDRAKANTH G REG NO: 710719104023

RESULT:
Thus the Diffie-Hellman key exchange algorithm has been implemented using Java Program and the
output has been verified successfully.