├── README.md
├── Dockerfile
├── birthdayAttck.java
├── BinaryVernam.java
├── docker.txt
├── Caesar.java
├── FindIt.java
├── SimpleHash.java
├── ECB.java
├── HMACExample.java
├── CTR.java
├── CBC.java
└── GCM.java


/README.md:
--------------------------------------------------------------------------------
1 | # PracticalCrypto
2 | Practical Cryptography Class
3 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM ubuntu
2 | MAINTAINER Kasun De Zoysa
3 | RUN apt-get update
4 | RUN apt-get install -y openssl
5 | 


--------------------------------------------------------------------------------
/birthdayAttck.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Kasun De Zoysa @ UCSC
 3 | */
 4 | import java.io.*;
 5 | import java.util.*;
 6 | 
 7 | public class birthdayAttck{
 8 | 
 9 |   public static void main(String args[]) {  
10 |   Random rand = new Random();
11 |   int n;
12 |   //for (int t = 0; t < 10; t++) {
13 |    Set<Integer> b = new HashSet<Integer>();
14 |    while (true) {
15 |         n = rand.nextInt(365);
16 |         if (!b.add(n)) break;
17 |     }
18 |     System.out.println("SET->"+b);
19 |     System.out.println("Birthbday->"+n+" Size->"+b.size());
20 |  // }
21 | }
22 | }
23 | 


--------------------------------------------------------------------------------
/BinaryVernam.java:
--------------------------------------------------------------------------------
 1 | public class BinaryVernam{
 2 | 
 3 | public static void main(String args[]){
 4 | char plain[]={'K','A','S','U','N'};
 5 | char cipher[]=new char[5];
 6 | char key[]={10,25,33,44,56};
 7 | int i,p,c;
 8 | 
 9 | //Encryption
10 | System.out.print("Encryption: ");
11 | for(i=0;i<plain.length;i++){
12 |  cipher[i]= (char) (plain[i]^key[i]);
13 |  System.out.print(cipher[i]);
14 | }
15 | 
16 | System.out.print("\nDecryption: ");
17 | 
18 | for(i=0;i<cipher.length;i++){
19 |  p=cipher[i]^key[i];
20 |  System.out.print((char)p);
21 | }
22 | System.out.println("");
23 | 
24 | }
25 | }
26 | 


--------------------------------------------------------------------------------
/docker.txt:
--------------------------------------------------------------------------------
 1 | 1. Download and install docker from store.docker.com
 2 |     https://docs.docker.com/docker-for-windows/
 3 | 
 4 | 2. Define the Dockerfile
 5 | FROM ubuntu
 6 | RUN apt-get update
 7 | RUN apt-get install -y openssl
 8 | 
 9 | 3. Build a Docker image 
10 | docker build -t openssl .
11 | 
12 | 4. Run a docker continer/Remove it
13 | docker run -v ~/UCSC/:/home --name ubuntu -it openssl
14 | docker container rm ubuntu
15 | 
16 | 5. List all Docker images
17 | docker images -a
18 | 
19 | 6. List all Docker containers
20 | docker container ps -a
21 | 
22 | 7. Start a docker container
23 | docker container start -ai id
24 | 
25 | 8. Attach input/output to the container
26 | docker container attach id
27 | 
28 | 9. clean up
29 | docker system prune -a
30 | 
31 | 


--------------------------------------------------------------------------------
/Caesar.java:
--------------------------------------------------------------------------------
 1 | //A Java Program to illustrate Caesar Cipher Technique
 2 | class Caesar{
 3 | 	// Encrypts text using a shift od s
 4 | 	public static StringBuffer encrypt(String text, int s) {
 5 | 		StringBuffer result= new StringBuffer();
 6 | 		char ch;
 7 | 		for (int i=0; i<text.length(); i++) {
 8 | 			if (Character.isUpperCase(text.charAt(i)))
 9 | 				ch = (char)(((int)text.charAt(i) + s - 65) % 26 + 65);
10 | 			else
11 | 				ch = (char)(((int)text.charAt(i) + s - 97) % 26 + 97);
12 | 
13 | 			result.append(ch);
14 | 			
15 | 		}
16 | 		return result;
17 | 	}
18 | 
19 | 	// Driver code
20 | 	public static void main(String[] args) {
21 | 		String text = "Hello KASUN";
22 | 		int s = 5;
23 | 		System.out.println("Text : " + text);
24 | 		System.out.println("Shift : " + s);
25 | 		System.out.println("Cipher: " + encrypt(text, s));
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/FindIt.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Kasun De Zoysa @ UCSC
 3 | */
 4 | import java.security.*;
 5 | import javax.crypto.*;
 6 | import javax.crypto.spec.*;
 7 | import java.util.Base64;
 8 | 
 9 | public class FindIt {
10 | 
11 | public static void main(String args[]) throws Exception {
12 | 
13 |   //Complete this programme to decrypt the
14 |   //following base64 encoded cipher text
15 |   String cText="A1TEAJWqY8c=";
16 |   //Decode the cyber text
17 |   byte[] ciphertext = Base64.getDecoder().decode(cText);
18 | 
19 |   //This ramdom generate is used to get key and iv
20 |    SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
21 |    sr.setSeed("1234".getBytes());
22 |    byte[] k = new byte[128/8];
23 |    sr.nextBytes(k);
24 |    SecretKeySpec   key = new SecretKeySpec(k,"AES");
25 | 
26 |    //Set a IV
27 | 
28 | 
29 |    //decryption pass
30 | 
31 |   System.out.println("Plain text length: "+plainText.length);
32 |   String s= new String(plainText);
33 |   System.out.println("plain text: " + s);
34 | 
35 |  }
36 | }
37 | 


--------------------------------------------------------------------------------
/SimpleHash.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Kasun De Zoysa @ UCSC
 3 | */
 4 | 
 5 | import java.security.*;
 6 | import java.io.*;
 7 | 
 8 | public class SimpleHash{
 9 | public static void main(String args[]) {
10 | 
11 |  try {
12 |    String data = "hello";
13 |    byte dataBytes[] = data.getBytes();
14 | 
15 |    MessageDigest md1 = MessageDigest.getInstance("SHA1");
16 |    md1.update(dataBytes);
17 |    byte digest1[] = md1.digest();
18 | 
19 |    System.out.println("Orig. digest: ");
20 |    for(byte b:digest1) System.out.format("%02x",b);
21 |    System.out.println("");
22 | 
23 |    String data2 = "hello";
24 |    MessageDigest md2 = MessageDigest.getInstance("SHA1");
25 |    md2.update(data2.getBytes());
26 |    byte digest2[] = md2.digest();
27 | 
28 |    System.out.println("New digest: ");
29 |    for(byte b:digest2) System.out.format("%02x",b);
30 |    System.out.println("");
31 | 
32 |    if(md2.isEqual(digest1,digest2))
33 |      System.out.println("Digest Verified");
34 |    else
35 |      System.out.println("Digest Verification failed!");
36 | 
37 | 
38 | 
39 |   } catch (Exception e) {
40 |      System.out.println(e);
41 |   }
42 | 
43 |  }
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/ECB.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Kasun De Zoysa @ UCSC
 3 | */
 4 | import java.io.*;
 5 | import java.security.*;
 6 | import javax.crypto.*;
 7 | import java.util.Formatter;
 8 | 
 9 | 
10 | public class ECB{
11 | 
12 |     public static void main(String[]    args) throws Exception {
13 |        String msg= "Hello123hello123";
14 |        byte[] input =msg.getBytes();
15 | 
16 | 
17 |  //Generate a key
18 |  KeyGenerator    generator = KeyGenerator.getInstance("AES");
19 |  generator.init(128);
20 |  Key key = generator.generateKey();
21 | 
22 | 
23 |         // encryption pass
24 |  Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
25 |      cipher.init(Cipher.ENCRYPT_MODE, key);
26 |      byte[] cipherText = cipher.doFinal(input);
27 | 
28 |  System.out.println("Cipher text length: " +cipherText.length);
29 |  System.out.println("Cipher text: " +byteArray2Hex(cipherText));
30 | 
31 |  // decryption pass
32 |     cipher.init(Cipher.DECRYPT_MODE, key);
33 |  byte[] plainText= cipher.doFinal(cipherText);
34 | 
35 |  System.out.println("Plain text length: "+plainText.length);
36 |     String s= new String(plainText);
37 |     System.out.println("plain text: " + s);
38 | 
39 |     }
40 | 
41 | 
42 | 
43 |    private static String byteArray2Hex(byte[] data) {
44 |      Formatter formatter = new Formatter();
45 |      for (byte b : data) formatter.format("%02x", b);
46 |      return formatter.toString();
47 |   }
48 | }
49 | 


--------------------------------------------------------------------------------
/HMACExample.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Kasun De Zoysa @ UCSC
 3 | */
 4 | import java.security.*;
 5 | import javax.crypto.*;
 6 | import javax.crypto.spec.*;
 7 | import java.io.*;
 8 | 
 9 | import java.util.*;
10 | 
11 | 
12 | public class HMACExample{
13 | 
14 | 
15 | 
16 | public static void main(String args[]) {
17 | 
18 |  try {
19 | 
20 |     String key1 = "MIS@UCSC";
21 |     SecretKeySpec sk1 = new SecretKeySpec(key1.getBytes(), "HMACSHA256");
22 | 
23 |     // Create a MAC object using HMAC-MD5 and initialize with key
24 |     Mac mac1 = Mac.getInstance("HMACSHA256");
25 |     mac1.init(sk1);
26 | 
27 | 
28 |     String data1 = "Hello kasun";
29 | 
30 |     byte[] digest1 = mac1.doFinal(data1.getBytes());
31 | 
32 |     System.out.println("Orig. HMAC: ");
33 |     for(byte b:digest1) System.out.format("%02x",b);
34 |     System.out.println("");
35 | 
36 |     //Verification
37 |     String key2 = "MIS@UCSC";
38 |     SecretKeySpec sk2 = new SecretKeySpec(key2.getBytes(), "HMACSHA256");
39 | 
40 |     Mac mac2 = Mac.getInstance("HMACSHA256");
41 |     mac2.init(sk2);
42 |     
43 |     String data2 = "Hello kasun";
44 | 
45 |     byte digest2[] = mac2.doFinal(data2.getBytes());
46 | 
47 | 
48 |     System.out.println("New HMAC: ");
49 |     for(byte b:digest2) System.out.format("%02x",b);
50 |     System.out.println("");
51 | 
52 |     if(Arrays.equals(digest1,digest2)) 
53 |      System.out.println("Digest Verified");
54 | 
55 |     else  
56 |      System.out.println("Digest Verification failed!");
57 | 
58 | 
59 | 
60 |   } catch (Exception e) {
61 | 
62 |      System.out.println(e);
63 | 
64 |   }
65 | 
66 |  }
67 | 
68 | }
69 | 
70 | 


--------------------------------------------------------------------------------
/CTR.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Kasun De Zoysa @ UCSC
 3 | */
 4 | import java.io.*;
 5 | import java.security.*;
 6 | import javax.crypto.*;
 7 | import java.util.Formatter;
 8 | import javax.crypto.spec.*;
 9 | 
10 | public class CTR{
11 | 
12 |     public static void main(String[]    args) throws Exception {
13 |        String msg= "Hello";
14 |        byte[] input =msg.getBytes();
15 | 
16 | 
17 | //Generate a key
18 |    KeyGenerator    generator = KeyGenerator.getInstance("DES");
19 |    generator.init(56);
20 |    Key key = generator.generateKey();
21 |  
22 | //Set a IV
23 |    byte iv[] = new byte[8];
24 |    SecureRandom secRandom = new SecureRandom() ;
25 |    secRandom.nextBytes(iv);
26 |    IvParameterSpec ivSpec = new IvParameterSpec(iv) ; 
27 | 
28 | // encryption pass
29 |      Cipher cipher = Cipher.getInstance("DES/CTR/NoPadding");
30 |      cipher.init(Cipher.ENCRYPT_MODE, key,ivSpec);
31 |      byte[] cipherText = cipher.doFinal(input);
32 | 
33 |  System.out.println("Cipher text length: " +cipherText.length);
34 |  System.out.println("Cipher text: " +byteArray2Hex(cipherText));
35 | 
36 |  // decryption pass
37 |     cipher.init(Cipher.DECRYPT_MODE, key,ivSpec);
38 |     byte[] plainText= cipher.doFinal(cipherText);
39 | 
40 |     System.out.println("Plain text length: "+plainText.length);
41 |     String s= new String(plainText);
42 |     System.out.println("plain text: " + s);
43 | 
44 |     }
45 | 
46 | 
47 |    private static String byteArray2Hex(byte[] data) {
48 |      Formatter formatter = new Formatter();
49 |      for (byte b : data) formatter.format("%02x", b);
50 |      return formatter.toString();
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/CBC.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | Kasun De Zoysa @ UCSC
 4 | */
 5 | import java.io.*;
 6 | import java.security.*;
 7 | import javax.crypto.*;
 8 | import java.util.Formatter;
 9 | import javax.crypto.spec.*;
10 | 
11 | public class CBC{
12 | 
13 |     public static void main(String[]    args) throws Exception {
14 |        String msg= "Hello123Hello123";
15 |        byte[] input =msg.getBytes();
16 | 
17 | 
18 | //Generate a key
19 |    KeyGenerator    generator = KeyGenerator.getInstance("AES");
20 |    generator.init(128);
21 |    Key key = generator.generateKey();
22 |  
23 | //Set a IV
24 |    byte iv[] = new byte[16];
25 |    SecureRandom secRandom = new SecureRandom() ;
26 |    secRandom.nextBytes(iv);
27 |    IvParameterSpec ivSpec = new IvParameterSpec(iv) ; 
28 | 
29 | // encryption pass
30 |      Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
31 |      cipher.init(Cipher.ENCRYPT_MODE, key,ivSpec);
32 |      byte[] cipherText = cipher.doFinal(input);
33 | 
34 |  System.out.println("Cipher text length: " +cipherText.length);
35 |  System.out.println("Cipher text: " +byteArray2Hex(cipherText));
36 | 
37 |  // decryption pass
38 |     cipher.init(Cipher.DECRYPT_MODE, key,ivSpec);
39 |     byte[] plainText= cipher.doFinal(cipherText);
40 | 
41 |     System.out.println("Plain text length: "+plainText.length);
42 |     String s= new String(plainText);
43 |     System.out.println("plain text: " + s);
44 | 
45 |     }
46 | 
47 | 
48 |    private static String byteArray2Hex(byte[] data) {
49 |      Formatter formatter = new Formatter();
50 |      for (byte b : data) formatter.format("%02x", b);
51 |      return formatter.toString();
52 |   }
53 | }
54 | 


--------------------------------------------------------------------------------
/GCM.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | Kasun De Zoysa @ UCSC
 4 | */
 5 | import java.io.*;
 6 | import java.security.*;
 7 | import javax.crypto.*;
 8 | import java.util.Formatter;
 9 | import javax.crypto.spec.*;
10 | 
11 | public class GCM{
12 | 
13 |     public static void main(String[]    args) throws Exception {
14 |        String msg= "Hello123";
15 |        byte[] input =msg.getBytes();
16 |        byte[] aadData = "10.4.5.6".getBytes() ;
17 | 
18 | 
19 | //Generate a key
20 |    KeyGenerator    generator = KeyGenerator.getInstance("AES");
21 |    generator.init(256);
22 |    Key key = generator.generateKey();
23 |  
24 | //Set a IV
25 |    byte iv[] = new byte[16];
26 |    SecureRandom secRandom = new SecureRandom() ;
27 |    secRandom.nextBytes(iv);
28 |    GCMParameterSpec ivSpec = new GCMParameterSpec(128, iv) ;
29 | 
30 | // encryption pass
31 |      Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
32 |      cipher.init(Cipher.ENCRYPT_MODE, key,ivSpec);
33 |      cipher.updateAAD(aadData) ;
34 |      byte[] cipherText = cipher.doFinal(input);
35 | 
36 |  System.out.println("Cipher text length: " +cipherText.length);
37 |  System.out.println("Cipher text: " +byteArray2Hex(cipherText));
38 | 
39 |  // decryption pass
40 |     cipher.init(Cipher.DECRYPT_MODE, key,ivSpec);
41 |     cipher.updateAAD(aadData) ;
42 |     byte[] plainText= cipher.doFinal(cipherText);
43 | 
44 |     System.out.println("Plain text length: "+plainText.length);
45 |     String s= new String(plainText);
46 |     System.out.println("plain text: " + s);
47 | 
48 |     }
49 | 
50 | 
51 |    private static String byteArray2Hex(byte[] data) {
52 |      Formatter formatter = new Formatter();
53 |      for (byte b : data) formatter.format("%02x", b);
54 |      return formatter.toString();
55 |   }
56 | }
57 | 


--------------------------------------------------------------------------------