rsa/main.c

#include <inttypes.h>
#include <math.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "helper.c"

uint64_t *dec_to_bin(uint64_t d, uint64_t *length) {
    uint64_t *binary_form = calloc(100, sizeof(uint64_t));
    int index = 0;
    while (d != 0) {
        binary_form[index] = d % 2;
        d /= 2;
        index++;
    }

    *length = index;

    return binary_form;
}

uint64_t quick_pow(uint64_t *d_binary, uint64_t a, uint64_t n, uint64_t length) {
    uint64_t *powed = calloc(100, sizeof(uint64_t));

    powed[0] = a;
    for (int i = 1; i <= length; i++) {
        powed[i] = (uint64_t)(((unsigned __int128)powed[i - 1] * powed[i - 1]) % n);
        // printf("powed: %ju, index: %d; ", powed[i], (i));
    }

    // check where in the binary are ones
    uint64_t multiplied = 1;
    for (int i = 0; i < length; i++) {
        if (d_binary[i] == 1) {
            multiplied = (uint64_t)(((unsigned __int128)multiplied * powed[i]) % n);
        }
    }

    // printf("\nbm quick math: %ju; %ju ", multiplied, n);

    free(powed);

    return multiplied;
}

bool prime_test(uint64_t n, int a) {
    // printf("\n\nprime test: %ju\n", n);
    // Miller Rabin prime test
    // choose a base: a, which should be a prime so that (n, a) = 1
    // then do 2 rounds of tests provided the first one did not fail
    // 1: a^d =k 1 mod n
    // 2: a^(d * 2^r) =k n-1 mod n
    // d = n-1 / 2^S (where S means how many time did we divide the number till we reached the first odd number)
    // S: see above
    // r = {0,... S-1}

    uint64_t d = n - 1;
    uint64_t S = 0;

    while (d % 2 == 0) {
        d = d / 2;
        S++;
    }

    uint64_t r = S - 1; // this stores the number of elements from 0 to S-1

    // round 1
    // 1: a^d =k 1 mod n
    uint64_t length = 0;
    uint64_t *d_binary = dec_to_bin(d, &length);
    uint64_t first_qp_res = quick_pow(d_binary, a, n, length);

    if (first_qp_res == 1) {
        free(d_binary);
        return true;
    }

    // round 2
    //  2: a^(d * 2^r) =k n-1 mod n
    for (int i = 0; i <= r; i++) {
        if (first_qp_res == n - 1) {
            free(d_binary);
            // printf("true\n");
            return true;
        } else if (first_qp_res < n - 2) {
            // printf("first_qp_res became smaller then n!!\n");
            break;
        } else {
            first_qp_res = (uint64_t)(((unsigned __int128)first_qp_res * first_qp_res) % n);
        }
    }

    free(d_binary);
    return false;
}

typedef struct {
    int base;
    uint64_t prime;
} prime_test_t;

void *prime_thread_worker(void *arg) {
    prime_test_t *result_ptr = (prime_test_t *)arg;

    do {
        result_ptr->prime = rand64();
        // printf("\nGenerating a new prime number (%p). Candidate: ", result_ptr);
        // printf("%ju", result_ptr->prime);
        // printf("\n");
    } while (!prime_test(result_ptr->prime, result_ptr->base));

    return NULL;
}

typedef struct {
    uint64_t lnko;
    __int128 x;
    __int128 y;
} euklidian_result_t;

euklidian_result_t euklidian_algorigthm_extended(unsigned __int128 a, unsigned __int128 b) {
    __int128 r = a % b, q = a / b, k = 1, xk = 0, yk = 1, next_r;
    __int128 prev_r = b, prev_q, prev_xk = 0, prev_yk = 1, prev_prev_xk = 1, prev_prev_yk = 0;
    euklidian_result_t res = {0, 0, 0};

    while (r != 0) {
        k++;

        prev_q = q;
        q = prev_r / r;

        next_r = prev_r % r;
        prev_r = r;
        r = next_r;

        xk = xk * prev_q + prev_prev_xk;
        prev_prev_xk = prev_xk;
        prev_xk = xk;

        yk = yk * prev_q + prev_prev_yk;
        prev_prev_yk = prev_yk;
        prev_yk = yk;
    }

    __int128 x = k % 2 == 0 ? prev_xk : -prev_xk;
    __int128 y = k % 2 == 0 ? -prev_yk : prev_yk;

    res.lnko = prev_r;
    res.x = x;
    res.y = y;

    return res;
}

int main() {
    uint64_t m = 0;
    printf("give input for m: \n");
    scanf("%ju", &m);

    srand(time(NULL));

    uint64_t base = 2;
    pthread_t thread_p, thread_q;
    prime_test_t p = {base, 0};
    prime_test_t q = {base, 0};

    pthread_create(&thread_p, NULL, prime_thread_worker, &p);
    pthread_create(&thread_q, NULL, prime_thread_worker, &q);

    pthread_join(thread_p, NULL);
    pthread_join(thread_q, NULL);

    printf("\n");

    p.prime = 11;
    q.prime = 29;

    unsigned __int128 n = p.prime * q.prime;
    print_uint128(n);
    printf("\n");

    unsigned __int128 fi_n = (p.prime - 1) * (q.prime - 1);
    print_uint128(fi_n);
    printf("\n");

    // 2. kulcsgeneralas
    uint64_t e = 0;
    do {
        e = rand64();
    } while (e <= 1 && e >= fi_n && prime_test(e, base));

    e = 17;

    euklidian_result_t calc_d = euklidian_algorigthm_extended(fi_n, e);
    __int128 d = calc_d.y;

    uint64_t length = 0;
    uint64_t *nyenye = dec_to_bin(e, &length);
    unsigned __int128 c = quick_pow(nyenye, m, n, length);
    free(nyenye);
    printf("\nc: ");
    print_uint128(c);

    return 0;
}