void montgomeryLadder(mpz_t result, mpz_t base, mpz_t exponent, mpz_t module) {
    mpz_t *array;
    for(int i = 0; i < 2; i++) {
        mpz_init(array[i]);
    }
    mpz_set_ui(array[0], 1);
    mpz_set(array[1], base);

    long k = mpz_sizeinbase(exponent, 2);
    for(int i = k - 1; i >= 0; i--) {
        int bit = mpz_tstbit(exponent, i);
        mpz_mul(array[!bit], array[0], array[1]);
        mpz_mod(array[!bit], array[!bit], module);
        mpz_mul(array[bit], array[bit], array[bit]);
        mpz_mod(array[bit], array[bit], module);
    }
    mpz_set(result, array[0]);
    for(int i = 0; i < 2; i++) {
        mpz_clear(array[i]);
    }
}







...


if(mpz_cmp_ui(gcdNumber,1) == 0) {
                        /* Original implementation with returning x^d, where x is a message */
                        /*mpz_t val;
                        mpz_init(val);
                        mpz_powm(val, number, privatekey, module);
                        long response_len=mpz_sizeinbase(val,10) + 2;
                        char *response = (char*) malloc(response_len);
                        mpz_get_str(response, 10, val);
                        n = write(newsockfd, response, strlen(response));
                        free(response);*/


                        /* Blinding in the server exponent to d to prevent timing attacks (Assignment 1) */
                        /*mpz_t r;
                        mpz_init(r);
                        coPrimeGen(r, module);
                        mpz_mod(r, r, module);
                        mpz_powm(r, r, publickey, module);
                        mpz_t message;
                        mpz_init(message);
                        mpz_mul(message, r, number);
                        mpz_mod(message, message, module);
                        mpz_powm(message, message, privatekey, module);

                        mpz_t rInverse;
                        mpz_init(rInverse);
                        mpz_invert(rInverse, r, module);

                        mpz_mul(message, message, rInverse);
                        mpz_mod(message, message, module);
                        long response_len=mpz_sizeinbase(message,10) + 2;
                        char *response = (char*) malloc(response_len);
                        mpz_get_str(response, 10, message);
                        n = write(newsockfd, response, strlen(response));
                        free(response);*/

                        /* Constant time exponentiation made with Montgomery's ladder */
                        mpz_t val;
                        mpz_init(val);
                        montgomeryLadder(val, number, privatekey, module);
                        long response_len=mpz_sizeinbase(val,10) + 2;
                        char *response = (char*) malloc(response_len);
                        mpz_get_str(response, 10, val);
                        n = write(newsockfd, response, strlen(response));
                        free(response);
                    }
                    else {
                        char *response = "Doesn't belong to Z*_{N}.";
                        n = write(newsockfd, response, strlen(response));
                    }