Add second year

second/semester1/CT255/Assessment/CT255-Assignment-4/DiffieHellman.java

@@ -0,0 +1,91 @@
+import java.util.ArrayList;
+
+public class DiffieHellman {
+
+    public static void main(String[] args) {
+        generate_params(); 
+    }
+
+    // method to generate the random DH parameters
+    public static void generate_params() {
+        int prime          = generate_prime();                           // generating a prime number     
+        System.out.println("prime: " + prime);
+        int primitive_root = generate_primitive_root(prime);             // generating a primitive root of that prime
+        System.out.println("prime: " + prime + ". primtive root : " + primitive_root);
+   }
+
+    // method to generate a prime number in the range 10000 - 100000
+    public static int generate_prime() {
+        // generating an ArrayList of prime numbers in the range 10,000 to 100,000 using the Sieve of Eratosthenes
+        // creating a list of consecutive integers from 2 through 100,000
+        ArrayList<Integer> integers = new ArrayList<Integer>();
+
+        for (int n = 2; n <= 100000; n++) {
+            integers.add(n);  
+        }
+
+        // initially, let p equal 2, the smallest prime number in the list.
+        int p = integers.get(0);
+
+        // variable to hold the number of known primes in the ArrayList
+        int primes_count = 1;
+
+        // looping while p is less than the final value in the list
+        while (p < integers.get(integers.size() - 1)) {
+            // removing the mutliples of p from the list
+            for (int i = 2; (i * p) <= integers.get(integers.size() - 1); i++) {
+                integers.remove(Integer.valueOf(i * p));
+            }
+        
+            // let p equal the new smallest element in the ArrayList
+            p = integers.get(primes_count++);
+        }
+
+        // cutting out the section of the ArrayList that contains prime number outside the appropriate range
+        while (integers.get(0) < 10000) {   // removing the first element of the ArrayList while the first index of the ArrayList holds a value less than 10,000  
+            integers.remove(0);
+        }
+
+        // selecting the element at a random index in the ArrayList of primes as our prime number
+        int prime = integers.get((int) (Math.random() * (integers.size() - 1)));
+
+        return prime;
+    }
+
+    public static int generate_primitive_root(int prime) {
+        // ArrayList<Integer> primitive_roots = new ArrayList<Integer>();  // ArrayList to hold the primitive roots found
+
+        // looping through all the numbers in the range 2 to the prime minus 1 to see if they're primitive roots of the prime, breaking when we find the first primitive root
+        for (int n = 3; n < prime - 1; n++) {
+            boolean is_n_a_primtive_root = true;                            // boolean to tell whether or not n is a primtive root
+            ArrayList<Integer> distinct_values = new ArrayList<Integer>();  // ArrayList to hold the distinct values of a candidate primitive root modulo the prime 
+            
+            // loop to check if n is a primitive root by raising it to the power of x modulo the prime
+            for (int x = 2; x < prime - 2; x++) {
+
+                // setting is_n_a_primtive_root to false and breaking out of the loop if n to the power of x modulo the prime is already in the distinct_values ArrayList
+                if (distinct_values.contains((n^x) % prime)) {
+                    is_n_a_primtive_root = false;
+                    System.out.println(n + " is not a primitive root");
+                    break;
+                }
+                else {
+                    distinct_values.add((n^x) % prime);
+                }
+            }
+            // adding n to the list of primitive roots if it is a primitive root of the prime passed to the function
+            if (is_n_a_primtive_root) {
+                // primitive_roots.add(n);
+                return n;
+            }
+        }
+
+        // selecting a random value in the list of primitive roots to be our primtitive root
+        // int random_primitive_root = primitive_roots.get((int) (Math.random() * (primitive_roots.size() - 1))); 
+        // int random_primitive_root = -1;
+        // return random_primitive_root;
+        //
+        // returning -1 if no primitive root found
+        return -1;
+    }
+}