92 lines
4.2 KiB
Java
92 lines
4.2 KiB
Java
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;
|
|
}
|
|
}
|