AIM: Write a C program that contains a string (char pointer) with a value \Hello World’.

The program should XOR each character in this

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

AIM: Write a Java program to perform encryption and decryption using Ceaser Cipher PROGRAM: 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 { 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; decrypted += (char) c; } return decrypted; } } Output: Enter any String: Hello World Enter the Key: 5 Encrypted String is: MjqqtBtwqi
Decrypted String is: Hello World

AIM: Write a Java program to perform encryption and decryption using the 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 { 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

AIM: Write a Java program to perform encryption and decryption using the 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
{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 = br.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++) { 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
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 { 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) { 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

AIM: Write a C/JAVA 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
{ 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) { cout.write(input); } fin.close(); cout.close(); } } OUTPUT: Initialization Vector of the Cipher: dI1MXzW97oQ= Contents of
inputFile.txt: Hello World Contents of outputFile.txt: ùJÖ ̃ NåI“

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!!"; KeyGenerator kgen = KeyGenerator.getInstance("AES"); kgen.init(128); byte[] raw =
skey.getEncoded(); SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES"); 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