rsa reborn mod working

rsa/Makefile

@@ -0,0 +1,18 @@
+NAME = rsa
+
+SRC = \
+	main.c \
+	rsa.c \
+	bigint.c \
+	array.c \
+	utils.c \
+
+all: $(NAME)
+
+$(NAME):
+	gcc -Wall -Wextra -Werror $(SRC) -o $(NAME)
+
+fclean:
+	rm -rf $(NAME)
+
+re: fclean all

rsa/array.c

@@ -0,0 +1,40 @@
+#include "rsa.h"
+
+void array_set_random_bytes(uint32_t *n, size_t size) {
+	int fd = open("/dev/urandom", O_RDONLY);
+	read(fd, n, size);
+}
+
+void array_set_msb_and_lsb_to_one(uint32_t *n, size_t size) {
+	n[0] |= 1;
+	n[size / sizeof(uint32_t) - 1] |= 1 << 31;
+}
+
+void array_bitwise_right_shift(uint32_t *a, size_t len) {
+	size_t size = sizeof(uint32_t) * 8 - 1;
+	for (size_t n = 0; n < len - 1; n++) {
+		a[n] = a[n] >> 1 | (a[n + 1] & 1) << size;
+	}
+	a[len - 1] >>= 1;
+}
+
+void array_bitwise_left_shift(uint32_t *a, size_t len) {
+	size_t size = sizeof(uint32_t) * 8 - 1;
+	for (size_t n = len - 1; n > 0; n--) {
+		a[n] = a[n] << 1 | ((a[n - 1] & (1 << size)) >> size);
+	}
+	a[0] <<= 1;
+}
+
+// Will underflow
+void array_decrement(uint32_t *a, size_t len) {
+	size_t cursor = 0;
+	size_t size = sizeof(uint32_t) * 8;
+	while (cursor < size * len) {
+		a[cursor / size] = a[cursor / size] ^ (1 << (cursor % size));
+		if (((a[cursor / size] >> (cursor % size)) & 1) == 0) {
+			return;
+		}
+		cursor += 1;
+	}
+}

rsa/bigint.c

@@ -0,0 +1,240 @@
+#include "rsa.h"
+
+void bigint_set_random_bytes(bigint_t n) {
+	int fd = open("/dev/urandom", O_RDONLY);
+	read(fd, n.data, n.len * sizeof(uint32_t));
+	close(fd);
+}
+
+void bigint_set_msb_and_lsb_to_one(bigint_t n) {
+	n.data[0] |= 1;
+	n.data[n.len - 1] |= 1 << 31;
+}
+
+void bigint_bitwise_right_shift(bigint_t n) {
+	size_t size = sizeof(uint32_t) * 8 - 1;
+	for (size_t i = 0; i < n.len - 1; i++) {
+		n.data[i] = n.data[i] >> 1 | (n.data[i + 1] & 1) << size;
+	}
+	n.data[n.len - 1] >>= 1;
+}
+
+void bigint_bitwise_left_shift(bigint_t n) {
+	size_t size = sizeof(uint32_t) * 8 - 1;
+	for (int i = n.len - 1; i > 0; i--) {
+		n.data[i] = n.data[i] << 1 | ((n.data[i - 1] & (1 << size)) >> size);
+	}
+	n.data[0] <<= 1;
+}
+
+bigint_t assignable_bigint_bitwise_left_shift(bigint_t n) {
+	bigint_t result = bigint_clone(n);
+	size_t size = sizeof(uint32_t) * 8 - 1;
+	for (int i = result.len - 1; i > 0; i--) {
+		result.data[i] = result.data[i] << 1 | ((result.data[i - 1] & (1 << size)) >> size);
+	}
+	result.data[0] <<= 1;
+	return result;
+}
+
+// Will underflow
+void bigint_decrement(bigint_t n) {
+	size_t cursor = 0;
+	size_t size = sizeof(uint32_t) * 8;
+	while (cursor < size * n.len) {
+		n.data[cursor / size] = n.data[cursor / size] ^ (1 << (cursor % size));
+		if (((n.data[cursor / size] >> (cursor % size)) & 1) == 0) {
+			return;
+		}
+		cursor += 1;
+	}
+}
+
+// TODO refactor/clean assume same length ?
+int bigint_cmp(bigint_t a, bigint_t b) {
+	uint32_t size = sizeof(uint32_t) * 8;
+	uint32_t acursor = size * a.len - 1;
+	uint32_t bcursor = size * b.len - 1;
+	printf("cursors a and b %d %d\n", acursor, bcursor);
+	while (acursor > bcursor) {
+		if (a.data[acursor / size] & (1 << acursor % size)) {
+			return 1;
+		}
+		acursor -= 1;
+	}
+	while (bcursor > acursor) {
+		if (b.data[bcursor / size] & (1 << bcursor % size)) {
+			return -1;
+		}
+		bcursor -= 1;
+	}
+	int cursor = acursor;
+	while (cursor >= 0) {
+		uint32_t abit = a.data[cursor / size] & (1 << (cursor % size));
+		uint32_t bbit = b.data[cursor / size] & (1 << (cursor % size));
+		//printf("cursor %d abit %ud bbit %ud\n", cursor, abit, bbit);
+		if (abit > bbit) {
+			return 1;
+		}
+		if (bbit > abit) {
+			return -1;
+		}
+		cursor -= 1;
+	}
+	return 0;
+}
+
+bigint_t assignable_bigint_substraction(bigint_t a, bigint_t b) {
+	if (a.len != b.len) {
+		printf("error: attempting to substract numbers of different length\n");
+		exit(1);
+	}
+
+	bigint_t result = bigint_clone(a);
+	bigint_t borrow = bigint_clone(b);
+	bigint_t y = bigint_clone(b);
+	bigint_t zero = bigint_zero(a.len);
+	while (bigint_cmp(borrow, zero)) {
+		for (size_t i = 0; i < a.len; i++) {
+			borrow.data[i] = ~result.data[i] & y.data[i];
+			result.data[i] = result.data[i] ^ y.data[i];
+		}
+		bigint_destroy(y);
+		y = assignable_bigint_bitwise_left_shift(borrow);
+	}
+	bigint_destroy(y);
+	bigint_destroy(borrow);
+	bigint_destroy(zero);
+	return result;
+}
+
+void bigint_substraction(bigint_t a, bigint_t b) {
+	if (a.len != b.len) {
+		printf("error: attempting to substract numbers of different length\n");
+		exit(1);
+	}
+
+	bigint_t borrow = bigint_clone(b);
+	bigint_t y = bigint_clone(b);
+	bigint_t zero = bigint_zero(a.len);
+	while (bigint_cmp(borrow, zero)) {
+		for (size_t i = 0; i < a.len; i++) {
+			borrow.data[i] = ~a.data[i] & y.data[i];
+			a.data[i] = a.data[i] ^ y.data[i];
+		}
+		bigint_destroy(y);
+		y = assignable_bigint_bitwise_left_shift(borrow);
+	}
+	bigint_destroy(y);
+	bigint_destroy(borrow);
+	bigint_destroy(zero);
+}
+
+bigint_t assignable_bigint_modulo(bigint_t a, bigint_t b) {
+	bigint_t result = bigint_clone(a);
+	bigint_t mod = bigint_clone(b);
+	printf("a = %ud\nb = %ud\nresult = %ud\nmod = %ud\n", a.data[0], b.data[0], result.data[0], mod.data[0]);	
+	if (bigint_cmp(result, b) == -1) {
+		bigint_destroy(mod);
+		return result;
+	}
+	bigint_bitwise_left_shift(mod);
+	printf("after bitwise_shift\na = %ud\nb = %ud\nresult = %ud\nmod = %ud\n", a.data[0], b.data[0], result.data[0], mod.data[0]);	
+	while (bigint_cmp(b, mod) == -1) {
+		while (bigint_cmp(result, mod) == 1) {
+			bigint_bitwise_left_shift(mod);
+	printf("DOUBLE after bitwise_shift\na = %ud\nb = %ud\nresult = %ud\nmod = %ud\n", a.data[0], b.data[0], result.data[0], mod.data[0]);	
+		}
+		bigint_bitwise_right_shift(mod);
+	printf("before sub \na = %ud\nb = %ud\nresult = %ud\nmod = %ud\n", a.data[0], b.data[0], result.data[0], mod.data[0]);	
+		if (bigint_cmp(result, mod) == 1) {
+		bigint_substraction(result, mod);
+
+	printf("subbed\na = %ud\nb = %ud\nresult = %ud\nmod = %ud\n", a.data[0], b.data[0], result.data[0], mod.data[0]);	
+		}
+		bigint_bitwise_right_shift(mod);
+	}
+		while (bigint_cmp(result, b) == 1) {
+		bigint_substraction(result, b);
+
+	printf("subbed\na = %ud\nb = %ud\nresult = %ud\nmod = %ud\n", a.data[0], b.data[0], result.data[0], mod.data[0]);	
+		}
+	return result;
+}
+
+void bigint_print(bigint_t n) {
+	for (int i = n.len - 1; i >= 0; i--) {
+		printf("bigint %ud\n", n.data[i]);
+	}
+}
+
+bigint_t bigint_clone(bigint_t src) {
+	bigint_t dst;
+
+	dst.len = src.len;
+	dst.data = (uint32_t *)protected_malloc(src.len * sizeof(uint32_t));
+	memcpy(dst.data, src.data, src.len * sizeof(uint32_t));
+
+	return dst;
+}
+
+bigint_t bigint_prime(size_t len) {
+	bigint_t n = bigint_new(len);
+
+	printf("new\n");
+	bigint_print(n);
+	bigint_set_random_bytes(n);
+	printf("random bytes\n");
+	bigint_print(n);
+	bigint_set_msb_and_lsb_to_one(n);
+	printf("msb and lsb set to tone\n");
+	bigint_print(n);
+
+	bigint_t d = bigint_clone(n);
+	d.data[0] -= 1;
+	uint32_t s = 0;
+	while (!d.data[0] & 1) {
+		bigint_bitwise_right_shift(d);
+		s += 1;
+	}
+
+	bigint_t two = bigint_zero(len);
+	two.data[0] = 2;
+	bigint_t n_minus_two = bigint_clone(d);
+	bigint_decrement(n_minus_two);
+
+	for (uint32_t k = 0; k < 128; k++) {
+		bigint_t a = bigint_zero(len);
+		while (bigint_cmp(a, two) == -1 || bigint_cmp(a, n_minus_two) == 1) {
+			printf("this is good %d\n", k);
+			bigint_set_random_bytes(a);
+		}
+		bigint_destroy(a);
+	}
+	return n;
+}
+
+bigint_t bigint_new(size_t len) {
+	bigint_t bigint;
+
+	bigint.len = len;
+	bigint.data = (uint32_t *)protected_malloc(len * sizeof(uint32_t));
+
+	return bigint;
+}
+
+bigint_t bigint_zero(size_t len) {
+	bigint_t bigint;
+
+	bigint = bigint_new(len);
+	for (size_t i = 0; i < len; i++) {
+		bigint.data[i] = 0;
+	}
+
+	return bigint;
+}
+
+void bigint_destroy(bigint_t n) {
+	free(n.data);
+	n.data = NULL;
+}

rsa/ft_itoa.c

@@ -1,37 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   ft_itoa.c                                          :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: gbrochar <marvin@42.fr>                    +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2015/11/29 09:56:59 by gbrochar          #+#    #+#             */
-/*   Updated: 2024/02/14 13:40:32 by gbrochar         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "rsa.h"
-
-char	*ft_itoa(int n)
-{
-	char	*str;
-	size_t	str_size;
-	int		n_mem;
-
-	n_mem = n;
-	str_size = (n < 0) ? 3 : 2;
-	while ((n > 9 || n < -9) && str_size++)
-		n /= 10;
-	str = (char *)malloc((str_size--) * sizeof(char));
-	if (!str)
-		return (NULL);
-	str[str_size--] = '\0';
-	while (n_mem > 9 || n_mem < -9)
-	{
-		str[str_size--] = (n_mem < 0) ? -(n_mem % 10) + '0' : n_mem % 10 + '0';
-		n_mem = n_mem / 10;
-	}
-	str[0] = (n_mem < 0) ? '-' : (n_mem + '0');
-	str[1] = (n_mem < 0) ? (-n_mem + '0') : str[1];
-	return (str);
-}

rsa/generate_keys.c

@@ -1,93 +0,0 @@
-#include "rsa.h"
-
-int *random_bits(int n) {
-	int fd = open("/dev/urandom", O_RDONLY);
-	ft_log(INFO, "fd");
-	ft_log(INFO, ft_itoa(fd));
-	int *random_bits = (int *)malloc(n >> 3);
-	if (!random_bits) {
-		ft_log(ERROR, "allocation failed on random_bits");
-		exit(1);
-	}
-	ft_log(INFO, "before read");
-	read(fd, random_bits, n >> 3, 0);
-	ft_log(INFO, "after read");
-	// set n bits to random values
-	// for (int i = 0; i < n >> 5; i++) {
-	//	random_bits[i] = rand();
-	// }
-	// set LSB and MSB to 1
-	random_bits[0] |= 1;
-	printf("last %ud\n", random_bits[(n / sizeof(int) >> 3) - 1]);
-	random_bits[(n / sizeof(int) >> 3) - 1] |= 0x80000000;
-	printf("last %ud\n", random_bits[(n / sizeof(int) >> 3) - 1]);
-	return random_bits;
-}
-
-void bitshift_array(int *a, int len) {
-	for (int n = 0; n < len - 1; n++) {
-		a[n] = a[n] >> 1 | (a[n + 1] & 1) << 31;
-	}
-	a[len - 1] >>= 1;
-}
-
-int *generate_a(int *n) {
-	int *a = (int *)malloc(RSA_SIZE_BYTES >> 1);
-	memcpy(a, n, RSA_SIZE_BYTES >> 1);
-	a[0] -= 1;
-	int cursor = 0;
-	// a = n - 2
-	while (1) {
-		a[cursor / 32] = a[cursor / 32] ^ (1 << (cursor % 32));
-		if ((a[cursor / 32] >> (cursor % 32)) & 1 == 0)
-			break;
-		cursor++;
-	}
-}
-
-int *large_mod(int *a, int *b) {
-	int len = RSA_SIZE_BYTES / sizeof(int) >> 1;
-	//for (int i = len - 1; i > -1; i--)
-}
-
-void generate_prime(int *n) {
-	ft_log(INFO, "Generating random RSA_SIZE / 2 bits number");
-	int *prime = random_bits(RSA_SIZE >> 1);
-	ft_log(INFO, "After random_bits");
-	printf("sizeof int : %d\n", sizeof(int));
-	for (int i = ((RSA_SIZE_BYTES / sizeof(int)) >> 1) - 1; i > -1; i--) {
-		printf("%ud\n", prime[i]);
-	}
-	int *d;
-	int s = 0;
-	ft_log(INFO, "Creating n - 1");
-	d = (int *)malloc(RSA_SIZE_BYTES >> 1);
-	memcpy(d, prime, RSA_SIZE_BYTES >> 1);
-	// d = n - 1 (n's LSB is guarrenteed to be 1)
-	d[0] -= 1;
-	for (int i = (RSA_SIZE_BYTES / sizeof(int) >> 1) - 1; i > -1; i--) {
-		printf("%ud\n", d[i]);
-	}
-	ft_log(INFO, "Factoriizing n - 1 as 2^s*d");
-	while (!(d[0] & 1)) {
-		s += 1;
-		bitshift_array(d, RSA_SIZE_BYTES / sizeof(int) >> 1);
-	}
-	for (int k = 0; k < 128; k++) {
-//		int *a = generate_a(prime);
-	}
-}
-
-int *ft_phi(int *p, int *q) {
-	return (int *)malloc(sizeof(int));
-}
-
-void generate_keys(int *p, int *q, int *e) {
-	ft_log(INFO, "Generating primes...");
-	p = 0;
-	q = 0;
-	e = 0;
-	generate_prime(p);
-	generate_prime(q);
-	int *phi = ft_phi(p, q);
-}

rsa/lib.c

@@ -1,15 +0,0 @@
-#include "rsa.h"
-
-void ft_log(int level, char *s) {
-	switch (level) {
-		case ERROR:
-			printf("error: %s\n", s);
-			break;
-		case WARNING:
-			printf("warning: %s\n", s);
-			break;
-		case INFO:
-			printf("info: %s\n", s);
-			break;
-	}
-}

rsa/main.c

@@ -1,26 +1,13 @@
 #include "rsa.h"
 
-/*
-int decrypt(int c) {
-}
-
-int encrypt(int m) {
-}
-*/
-
 int main(int ac, char **av) {
 	if (ac == 2) {
-		ft_log(INFO, ft_itoa(RAND_MAX));
-		int m = atoi(av[1]);
-		srand(time(NULL));
-		int *p;
-		int *q;
-		int *e;
-		ft_log(INFO, "Generating keys...");
-		generate_keys(p, q, e);
-	} else {
-		ft_log(WARNING, "Need to pass message as argument");
-		return 1;
+		(void)av;
+		rsa_t rsa = rsa_generate_keys(RSA_BLOCK_SIZE);
+		(void)rsa;
+	}
+	else {
+		printf("usage: ./rsa message\n");
 	}
 	return 0;
 }

rsa/rsa.c

@@ -0,0 +1,84 @@
+#include "rsa.h"
+
+rsa_t rsa_init(size_t len) {
+	rsa_t rsa;
+
+//	rsa.p = bigint_prime(len / 2);
+//	rsa.q = bigint_prime(len / 2);
+
+	rsa.p = bigint_zero(len / 2);
+	rsa.q = bigint_zero(len / 2);
+	return rsa;
+}
+
+rsa_t rsa_generate_keys(size_t block_size) {
+	size_t len = block_size / sizeof(uint32_t) / 8;
+	rsa_t rsa = rsa_init(len);
+
+	bigint_t a = bigint_zero(4);
+	bigint_t b = bigint_zero(4);
+
+	a.data[0] = 1234567890;
+	b.data[0] = 234567;
+	
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	
+	a.data[0] = 1234567890;
+//	b.data[0] = 1921572864;
+
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+
+/*
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	printf("cmp b and a %d\n", bigint_cmp(b, a));
+
+	bigint_bitwise_left_shift(b);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("b %ud\n", b.data[0]);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("b %ud\n", b.data[0]);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("b %ud\n", b.data[0]);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("b %ud\n", b.data[0]);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("b %ud\n", b.data[0]);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("b %ud\n", b.data[0]);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("b %ud\n", b.data[0]);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("b %ud\n", b.data[0]);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+	bigint_bitwise_left_shift(b);
+	printf("b %ud\n", b.data[0]);
+	printf("cmp a and b %d\n", bigint_cmp(a, b));
+*/
+	bigint_t result = assignable_bigint_modulo(a, b);
+
+	printf("result is %ud\n", result.data[0]);
+
+	return rsa;
+}

rsa/rsa.h

@@ -1,29 +1,51 @@
 #ifndef _RSA_H
 #define _RSA_H 1
 
-#include <math.h>
+#include <stdint.h>
 #include <stdio.h>
+#include <stddef.h>
 #include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <sys/mman.h>
 #include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
 
-// TODO remove bytes bits helper
-#define RSA_SIZE 1024 
-#define RSA_SIZE_BYTES 1024 / 8 
+#define RSA_BLOCK_SIZE 2048
 
-#define ERROR 0
-#define WARNING 1
-#define INFO 2
+typedef struct bigint_s {
+	uint32_t *data;
+	size_t len;
+} bigint_t;
 
-void ft_log(int level, char *s);
+typedef struct rsa_s {
+	bigint_t p;
+	bigint_t q;
+} rsa_t;
 
-char *ft_itoa(int n);
 
-void generate_keys(int *p, int *q, int *e);
-int *random_bits(int n);
-void generate_prime(int *p);
-int *phi(int *p, int *q);
+void *protected_malloc(size_t size);
+
+rsa_t rsa_generate_keys(size_t block_size);
+
+
+void bigint_set_random_bytes(bigint_t n);
+void bigint_set_msb_and_lsb_to_one(bigint_t n);
+void bigint_bitwise_left_shift(bigint_t n);
+void bigint_bitwise_right_shift(bigint_t n);
+void bigint_decrement(bigint_t n);
+int bigint_cmp(bigint_t a, bigint_t b);
+bigint_t bigint_prime(size_t len);
+void bigint_print(bigint_t n);
+bigint_t bigint_new(size_t len);
+bigint_t bigint_zero(size_t len);
+bigint_t bigint_clone(bigint_t src);
+bigint_t assignable_bigint_modulo(bigint_t a, bigint_t b);
+
+void bigint_destroy(bigint_t n);
+
+void array_set_random_bytes(uint32_t *n, size_t size);
+void array_set_msb_and_lsb_to_one(uint32_t *n, size_t size);
+void array_bitwise_right_shift(uint32_t *a, size_t len);
+void array_bitwise_right_shift(uint32_t *a, size_t len);
+void array_decrement(uint32_t *a, size_t len);
 
 #endif

rsa/utils.c

@@ -0,0 +1,9 @@
+#include "rsa.h"
+
+void *protected_malloc(size_t size) {
+	void *ptr = malloc(size);
+	if (!ptr) {
+		printf("malloc returned NULL");
+	}
+	return ptr;
+}