Merge branch 'rsa' into rot1

.gitignore

@@ -1,3 +1,6 @@
+rsa/rsa
+rsa64/rsa
+*.swp
 *.o
 *.a
 woody_woodpacker

rsa64/Makefile

@@ -0,0 +1,43 @@
+NAME = rsa
+
+SRC = \
+	main.c \
+	rsa.c \
+	utils.c \
+	primes.c \
+
+all: $(NAME)
+
+$(NAME):
+	gcc -Wall -Wextra -Werror -Wunused-function $(SRC) -o $(NAME)
+
+fast:
+	gcc -Wall -Wextra -Werror -Wunused-function -O3 $(SRC) -o $(NAME)
+
+fast-info:
+	gcc -Wall -Wextra -Werror -Wunused-function -O3 -fopt-info $(SRC) -o $(NAME)
+
+really-fast:
+	gcc -Wall -Wextra -Werror -Wunused-function -O3 -march=native $(SRC) -o $(NAME)
+
+really-fast-info:
+	gcc -Wall -Wextra -Werror -Wunused-function -O3 -march=native -fopt-info $(SRC) -o $(NAME)
+
+profile:
+	gcc -Wall -Wextra -Werror -Wunused-function -pg $(SRC) -o $(NAME)
+
+profile-clang:
+	clang -Wall -Wextra -Werror -Wunused-function -pg $(SRC) -o $(NAME)
+
+profile-fast:
+	gcc -Wall -Wextra -Werror -Wunused-function -O3 -pg $(SRC) -o $(NAME)
+
+profile-fast-clang:
+	clang -Wall -Wextra -Werror -Wunused-function -O3 -pg $(SRC) -o $(NAME)
+
+fclean:
+	rm -rf $(NAME)
+
+re: fclean all
+
+.PHONY: all fast profile profile-fast fclean re

rsa64/main.c

@@ -0,0 +1,14 @@
+#include "rsa.h"
+
+int main(int ac, char **av) {
+	if (ac == 2) {
+		(void)av;
+		rsa_t rsa = rsa_generate_keys();
+		(void)rsa;
+	}
+	else {
+		printf("usage: ./rsa message\n");
+	}
+	return 0;
+}
+

rsa64/primes.c

@@ -0,0 +1,74 @@
+#include "rsa.h"
+
+uint16_t get_random_bytes(int fd) {
+	uint16_t ret;
+	if (read(fd, &ret, sizeof(uint16_t)) == -1) {
+		exit(1);
+	}
+	return ret;
+}
+
+// n pow e mod m
+uint64_t pow_mod(uint64_t n, uint64_t e, uint64_t m) {
+	uint64_t y = 1;
+
+	while (e > 1) {
+		if (e & 1) {
+			y = (y * n) % m;
+		}
+		n = (n * n) % m;
+		e = e >> 1;
+	}
+	return (n * y) % m;
+}
+
+bool is_prime(uint16_t n, size_t k_max, int fd) {
+	uint16_t a = get_random_bytes(fd);
+	uint16_t d = n - 1;
+	uint16_t s = 0;
+
+	while ((d & 1) == 0) {
+		s++;
+		d = d >> 1;
+	}
+
+	for (size_t k = 0; k < k_max; k++) {
+		a = 0;
+		while (a < 2 || a > (n - 2)) {
+			a = get_random_bytes(fd);
+		}
+		uint16_t x = pow_mod(a, d, n);
+		uint16_t y;
+		for (uint16_t i = 0; i < s; i++) {
+			y = pow_mod(x, 2, n);
+			if (y == 1 && x != 1 && x != n - 1)
+				return false;
+			x = y;
+		}
+		if (y != 1) {
+			return false;
+		}
+	}
+	return true;
+}
+
+uint16_t generate_prime_fd(int fd) {
+	uint16_t n = get_random_bytes(fd);
+	n |= 1 << 15;
+	n |= 1;
+
+	while (!is_prime(n, 16, fd)) {
+		n = get_random_bytes(fd);
+		n |= 1 << 15;
+		n |= 1;
+	}
+	return n;
+}
+
+uint16_t generate_prime() {
+	int fd = open("/dev/urandom", O_RDONLY);
+	uint16_t n = generate_prime_fd(fd);
+	close(fd);
+	return n;
+}
+

rsa64/rsa.c

@@ -0,0 +1,111 @@
+#include "rsa.h"
+
+int64_t euler(int64_t r0, int64_t r1) {
+	int64_t s0 = 1;
+	int64_t s1 = 0;
+	int64_t t0 = 0;
+	int64_t t1 = 1;
+	int64_t q0 = 0;
+
+	while (r1 != 0) {
+		q0 = r0 / r1;
+		int64_t tmp = r0 % r1;
+		r0 = r1;
+		r1 = tmp;
+		tmp = s0 - q0 * s1;
+		s0 = s1;
+		s1 = tmp;
+		tmp = t0 - q0 * t1;
+		t0 = t1;
+		t1 = tmp;
+	}
+	return s0;
+}
+
+rsa_t rsa_generate_keys(void) {
+	for (int try = 0; try < 1000; try++) {
+
+	if (try % 100 == 0)
+		printf("try: %d\n", try);
+	int64_t p = (uint64_t)generate_prime();
+	int64_t q = (uint64_t)generate_prime();
+	int64_t ln = (p - 1) * (q - 1);
+	int64_t e = 11317;
+
+	while (ln % e == 0 || p == q) {
+		p = generate_prime();
+		q = generate_prime();
+		ln = (p - 1) * (q - 1);
+	}
+
+	if (q > p) {
+		uint64_t tmp = p;
+		p = q;
+		q = tmp;
+	}
+	int64_t n = p * q;
+
+	int64_t r0 = e;
+	int64_t r1 = ln;
+	int64_t s0 = 1;
+	int64_t s1 = 0;
+	int64_t t0 = 0;
+	int64_t t1 = 1;
+	int64_t q0 = 0;
+
+	while (r1 != 0) {
+		q0 = r0 / r1;
+		int64_t tmp = r0 % r1;
+		r0 = r1;
+		r1 = tmp;
+		tmp = s0 - q0 * s1;
+		s0 = s1;
+		s1 = tmp;
+		tmp = t0 - q0 * t1;
+		t0 = t1;
+		t1 = tmp;
+	}
+
+	int64_t d = euler(e, ln) + ln;
+	if (d > n) {
+		d -= ln;
+	}
+
+/*	printf("p: %ld\n", p);
+	printf("q: %ld\n", q);
+	printf("ln: %ld\n", ln);
+	printf("n: %ld\n", n);
+	printf("d: %ld\n", d);
+	printf("e: %ld\n", e);
+	printf("d * e %% ln = %ld\n", (d*e)%ln);*/
+	for (uint64_t m = 0; m < 16384; m++) {
+		//uint64_t m = get_random_bytes(fd2);
+		uint64_t c = pow_mod(m, e, n);
+		uint64_t m2 = pow_mod(c, d, n);
+		if (m != m2) {
+			printf("ERROR try: %d\nround: n/a\nmsg: %ld\ncypher: %ld\ndecrypted: %ld\nd: %ld\ne: %ld\np: %lu\nq: %lu\nn: %lu\n", try, m, c, m2, d, e, p, q, n);
+			break;
+		}
+	}
+	//int64_t m = 42;
+	/*
+	for (int64_t m = 41; m < 43; m++) {
+	int64_t c = pow_mod(m, e, n);
+	int64_t m2 = pow_mod(c, d, n);
+	if (d < 0) {
+		int64_t c2 = euler(c, n);
+		printf("c2: %ld\n", c2);
+		printf("c2 * c %% n = %ld\n", ((c2 + n)*c)%n);
+		printf("c2 * c %% n = %ld\n", ((c2)*c)%n);
+		m2 = pow_mod(c2 + n, -d, n);
+	}
+	printf("message: %ld\n", m);
+	printf("cypher: %ld\n", c);
+	printf("decrypted: %ld\n", m2);
+	}*/
+	}
+	rsa_t rsa;
+	rsa.p.len = 42;
+	return rsa;
+}
+

rsa64/rsa.h

@@ -0,0 +1,34 @@
+#ifndef _RSA_H
+#define _RSA_H 1
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdbool.h>
+
+#define RSA_BLOCK_SIZE 128
+
+typedef struct bigint_s {
+	uint32_t *data;
+	size_t len;
+} bigint_t;
+
+typedef struct rsa_s {
+	bigint_t p;
+	bigint_t q;
+} rsa_t;
+
+void *protected_malloc(size_t size);
+
+rsa_t rsa_generate_keys();
+
+uint16_t generate_prime();
+uint64_t pow_mod(uint64_t nn, uint64_t e, uint64_t mm);
+uint16_t get_random_bytes(int fd);
+
+#endif
+

rsa64/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;
+}