feat: rsa 64bits prime gen
This commit is contained in:
parent
ee899b8c8c
commit
17cd4fde5b
|
|
@ -0,0 +1,45 @@
|
|||
NAME = rsa
|
||||
|
||||
SRC = \
|
||||
main.c \
|
||||
rsa.c \
|
||||
bigint.c \
|
||||
array.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
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#include "rsa.h"
|
||||
|
||||
void array_set_random_bytes(uint32_t *n, size_t size) {
|
||||
int fd = open("/dev/urandom", O_RDONLY);
|
||||
if (read(fd, n, size) == -1) {
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,342 @@
|
|||
#include "rsa.h"
|
||||
|
||||
void my_memcpy(void *dst, void *src, size_t n) {
|
||||
memcpy(dst, src, n);
|
||||
}
|
||||
|
||||
void bigint_set_random_bytes(bigint_t n, size_t len) {
|
||||
int fd = open("/dev/urandom", O_RDONLY);
|
||||
if (read(fd, n.data, len * sizeof(uint32_t)) == -1) {
|
||||
exit(1);
|
||||
}
|
||||
close(fd);
|
||||
}
|
||||
|
||||
void bigint_set_msb_and_lsb_to_one(bigint_t n, size_t len) {
|
||||
n.data[0] |= 1;
|
||||
n.data[len - 1] |= 1 << 31;
|
||||
}
|
||||
|
||||
void bigint_bitwise_right_shift(bigint_t n) {
|
||||
for (size_t i = 0; i < n.len - 1; i++) {
|
||||
n.data[i] = n.data[i] >> 1 | (n.data[i + 1] & 1) << 31;
|
||||
}
|
||||
n.data[n.len - 1] >>= 1;
|
||||
}
|
||||
|
||||
void bigint_bitwise_left_shift(bigint_t n) {
|
||||
for (int i = n.len - 1; i > 0; i--) {
|
||||
n.data[i] = n.data[i] << 1 | ((n.data[i - 1] & (1 << 31)) >> 31);
|
||||
}
|
||||
n.data[0] <<= 1;
|
||||
}
|
||||
|
||||
void move_bigint_bitwise_left_shift(bigint_t n, bigint_t result) {
|
||||
for (int i = result.len - 1; i > 0; i--) {
|
||||
result.data[i] = n.data[i] << 1 | ((n.data[i - 1] & (1 << 31)) >> 31);
|
||||
}
|
||||
result.data[0] = n.data[0] << 1;
|
||||
}
|
||||
|
||||
// Will underflow
|
||||
void bigint_decrement(bigint_t n) {
|
||||
size_t cursor = 0;
|
||||
while (cursor < n.len << 5) {
|
||||
n.data[cursor >> 32] = n.data[cursor >> 5] ^ (1 << (cursor % 32));
|
||||
if (((n.data[cursor >> 5] >> (cursor % 32)) & 1) == 0) {
|
||||
return;
|
||||
}
|
||||
cursor += 1;
|
||||
}
|
||||
}
|
||||
|
||||
// TODO refactor/clean assume same length ?
|
||||
int64_t bigint_cmp(bigint_t a, bigint_t b) {
|
||||
int cursor = a.len - 1;
|
||||
while (cursor >= 0) {
|
||||
if (a.data[cursor] > b.data[cursor]) {
|
||||
return 1;
|
||||
}
|
||||
if (b.data[cursor] > a.data[cursor]) {
|
||||
return -1;
|
||||
}
|
||||
cursor -= 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// TODO refactor/clean assume same length ?
|
||||
int bigint_dif(bigint_t a, bigint_t b) {
|
||||
int cursor = a.len;
|
||||
while (--cursor >= 0) {
|
||||
if (a.data[cursor] ^ b.data[cursor]) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int is_zero(bigint_t n) {
|
||||
for (size_t i = 0; i < n.len; i++) {
|
||||
if (n.data[i]) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
// TODO check opti
|
||||
void bigint_substraction(bigint_t a, bigint_t b, bigint_t borrow, bigint_t y) {
|
||||
my_memcpy(y.data, b.data, b.len * sizeof(uint32_t));
|
||||
while (!is_zero(y)) {
|
||||
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];
|
||||
}
|
||||
move_bigint_bitwise_left_shift(borrow, y);
|
||||
}
|
||||
}
|
||||
|
||||
// TODO check opti
|
||||
void custom_bigint_modulo(bigint_t a, bigint_t b, bigint_t result, bigint_t mod, bigint_t borrow_sub, bigint_t y_sub) {
|
||||
bigint_set_zeros(result);
|
||||
my_memcpy(result.data, a.data, a.len * sizeof(uint32_t));
|
||||
if (bigint_cmp(result, b) < 0) {
|
||||
return ;
|
||||
}
|
||||
while (bigint_cmp(result, mod) > 0) {
|
||||
bigint_bitwise_left_shift(mod);
|
||||
}
|
||||
while (bigint_cmp(b, mod) < 0) {
|
||||
bigint_bitwise_right_shift(mod);
|
||||
if (bigint_cmp(result, mod) > 0) {
|
||||
bigint_substraction(result, mod, borrow_sub, y_sub);
|
||||
}
|
||||
}
|
||||
while (bigint_cmp(result, b) > -1) {
|
||||
bigint_substraction(result, b, borrow_sub, y_sub);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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));
|
||||
my_memcpy(dst.data, src.data, src.len * sizeof(uint32_t));
|
||||
|
||||
return dst;
|
||||
}
|
||||
|
||||
void bigint_destroy(bigint_t n) {
|
||||
free(n.data);
|
||||
n.data = NULL;
|
||||
}
|
||||
|
||||
void custom_bigint_add(bigint_t a, bigint_t b, int index) {
|
||||
uint64_t carriage = 0;
|
||||
|
||||
for (size_t cursor = 0; cursor < a.len; cursor++) {
|
||||
uint64_t tmp = (uint64_t)a.data[cursor] + carriage;
|
||||
if ((int)cursor - index >= 0) {
|
||||
tmp += (uint64_t)b.data[cursor - index];
|
||||
}
|
||||
a.data[cursor] = (uint32_t)tmp;
|
||||
carriage = tmp >> 32;
|
||||
}
|
||||
}
|
||||
|
||||
void bigint_set_zeros(bigint_t n) {
|
||||
for (size_t i = 0; i < n.len; i++) {
|
||||
n.data[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void custom_bigint_mul(bigint_t a, bigint_t b, bigint_t result, bigint_t *b_tool) {
|
||||
int width = a.len * 32;
|
||||
bigint_set_zeros(result);
|
||||
bigint_set_zeros(b_tool[0]);
|
||||
my_memcpy(b_tool[0].data, b.data, b.len * sizeof(uint32_t));
|
||||
|
||||
for (int i = 1; i < 32; i++) {
|
||||
bigint_set_zeros(b_tool[i]);
|
||||
my_memcpy(b_tool[i].data, b_tool[i - 1].data, b.len * sizeof(uint32_t));
|
||||
bigint_bitwise_left_shift(b_tool[i]);
|
||||
}
|
||||
|
||||
for (int cursor = 0; cursor < width; cursor++) {
|
||||
int offset = cursor % 32;
|
||||
int index = cursor >> 5;
|
||||
if (a.data[index] >> offset & 1) {
|
||||
custom_bigint_add(result, b_tool[offset], index);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// a^e mod n
|
||||
// clean memory tricks !!!
|
||||
void custom_bigint_pow_mod(bigint_t a, bigint_t e, bigint_t n, bigint_t result, bigint_t custom, bigint_t custom2, bigint_t mod, bigint_t borrow_sub, bigint_t y_sub, bigint_t *b_tool) {
|
||||
bigint_set_zeros(result);
|
||||
bigint_set_zeros(custom);
|
||||
bigint_set_zeros(custom2);
|
||||
my_memcpy(result.data, a.data, a.len * sizeof(uint32_t));
|
||||
int cursor = (e.len << 5) - 1;
|
||||
while (!(e.data[cursor >> 5] & 1 << (cursor % 32))) {
|
||||
cursor--;
|
||||
}
|
||||
cursor--;
|
||||
while (cursor >= 0) {
|
||||
custom_bigint_mul(result, result, custom, b_tool);
|
||||
custom_bigint_modulo(custom, n, custom2, mod, borrow_sub, y_sub);
|
||||
bigint_set_zeros(result);
|
||||
my_memcpy(result.data, custom2.data, custom2.len * sizeof(uint32_t));
|
||||
if (e.data[cursor >> 5] & 1 << (cursor % 32)) {
|
||||
custom_bigint_mul(result, a, custom, b_tool);
|
||||
custom_bigint_modulo(custom, n, custom2, mod, borrow_sub, y_sub);
|
||||
my_memcpy(result.data, custom2.data, custom2.len * sizeof(uint32_t));
|
||||
}
|
||||
cursor -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
void bigint_print(bigint_t n) {
|
||||
for (int i = n.len - 1; i >= 0; i--) {
|
||||
printf("bigint %ud\n", n.data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void bulk_destroy(bigint_t x, bigint_t y, bigint_t n, bigint_t d, bigint_t two, bigint_t one, bigint_t n_minus_two, bigint_t n_minus_one) {
|
||||
bigint_destroy(x);
|
||||
bigint_destroy(y);
|
||||
bigint_destroy(n);
|
||||
bigint_destroy(d);
|
||||
bigint_destroy(two);
|
||||
bigint_destroy(one);
|
||||
bigint_destroy(n_minus_two);
|
||||
bigint_destroy(n_minus_one);
|
||||
}
|
||||
|
||||
int prime_division(bigint_t *primes, bigint_t n, bigint_t mod, bigint_t custom2, bigint_t borrow_sub, bigint_t y_sub) {
|
||||
bigint_set_zeros(mod);
|
||||
for (int i = 0; i < 200; i++) {
|
||||
mod.data[0] = primes[i].data[0];
|
||||
custom_bigint_modulo(n, primes[i], custom2, mod, borrow_sub, y_sub);
|
||||
if (is_zero(custom2)) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int miller_rabin(size_t len, bigint_t a, bigint_t two, bigint_t n_minus_two, bigint_t d, bigint_t n, bigint_t x, bigint_t custom, bigint_t custom2, bigint_t mod, bigint_t borrow_sub, bigint_t y_sub, bigint_t *b_tool, bigint_t n_minus_one, uint32_t s, bigint_t y, bigint_t one) {
|
||||
for (uint32_t k = 0; k < 20; k++) {
|
||||
bigint_set_zeros(a);
|
||||
while (bigint_cmp(a, two) < 0 || bigint_cmp(a, n_minus_two) > 0) {
|
||||
bigint_set_random_bytes(a, len);
|
||||
}
|
||||
custom_bigint_pow_mod(a, d, n, x, custom, custom2, mod, borrow_sub, y_sub, b_tool);
|
||||
for (uint32_t i = 0; i < s; i++) {
|
||||
custom_bigint_pow_mod(x, two, n, y, custom, custom2, mod, borrow_sub, y_sub, b_tool);
|
||||
if (!bigint_dif(y, one) && bigint_dif(x, one) && bigint_dif(x, n_minus_one)) {
|
||||
return 0;
|
||||
}
|
||||
bigint_destroy(x);
|
||||
x = bigint_clone(y);
|
||||
}
|
||||
if (bigint_dif(y, one)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
bigint_t bigint_prime(size_t len, bigint_t *primes) {
|
||||
size_t my_size = len * 2;
|
||||
|
||||
bigint_t n = bigint_zero(my_size);
|
||||
|
||||
bigint_set_random_bytes(n, len);
|
||||
bigint_set_msb_and_lsb_to_one(n, len);
|
||||
bigint_t mod = bigint_clone(n);
|
||||
bigint_t borrow_sub = bigint_clone(n);
|
||||
bigint_t y_sub = bigint_clone(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 x = bigint_zero(my_size);
|
||||
bigint_t y = bigint_zero(my_size);
|
||||
bigint_t custom = bigint_zero(my_size);
|
||||
bigint_t custom2 = bigint_zero(my_size);
|
||||
|
||||
|
||||
if (prime_division(primes, n, mod, custom2, borrow_sub, y_sub)) {
|
||||
bulk_destroy(x, y, n, d, custom, custom2, mod, borrow_sub);
|
||||
bigint_destroy(y_sub);
|
||||
return bigint_prime(len, primes);
|
||||
}
|
||||
memcpy(mod.data, n.data, n.len * sizeof(uint32_t));
|
||||
|
||||
bigint_t *b_tool = (bigint_t *)protected_malloc(32 * sizeof(bigint_t));
|
||||
for (int i = 0; i < 32; i++) {
|
||||
b_tool[i] = bigint_zero(my_size * 2);
|
||||
}
|
||||
|
||||
bigint_t two = bigint_zero(my_size);
|
||||
bigint_t one = bigint_zero(my_size);
|
||||
two.data[0] = 2;
|
||||
one.data[0] = 1;
|
||||
bigint_t n_minus_two = bigint_clone(n);
|
||||
bigint_t n_minus_one = bigint_clone(n);
|
||||
n_minus_two.data[0] -= 1;
|
||||
n_minus_one.data[0] -= 1;
|
||||
bigint_decrement(n_minus_two);
|
||||
bigint_t a = bigint_zero(my_size);
|
||||
|
||||
int is_prime = miller_rabin(len, a, two, n_minus_two, d, n, x, custom, custom2, mod, borrow_sub, y_sub, b_tool, n_minus_one, s, y, one);
|
||||
|
||||
bulk_destroy(x, y, custom, d, two, one, n_minus_two, n_minus_one);
|
||||
bigint_destroy(custom2);
|
||||
bigint_destroy(a);
|
||||
bigint_destroy(mod);
|
||||
bigint_destroy(borrow_sub);
|
||||
bigint_destroy(y_sub);
|
||||
for (int i = 0; i < 32; i++) {
|
||||
bigint_destroy(b_tool[i]);
|
||||
}
|
||||
free(b_tool);
|
||||
|
||||
if (is_prime) {
|
||||
return n;
|
||||
}
|
||||
bigint_destroy(n);
|
||||
return bigint_prime(len, primes);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
#include "rsa.h"
|
||||
|
||||
int main(int ac, char **av) {
|
||||
if (ac == 2) {
|
||||
(void)av;
|
||||
rsa_t rsa = rsa_generate_keys(RSA_BLOCK_SIZE);
|
||||
(void)rsa;
|
||||
}
|
||||
else {
|
||||
printf("usage: ./rsa message\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,77 @@
|
|||
#include "rsa.h"
|
||||
|
||||
uint32_t get_random_bytes(int fd) {
|
||||
uint32_t ret;
|
||||
if (read(fd, &ret, sizeof(uint32_t)) == -1) {
|
||||
exit(1);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
// nn pow e mod mm
|
||||
uint32_t pow_mod(uint32_t nn, uint32_t e, uint32_t mm) {
|
||||
uint64_t x = nn;
|
||||
uint64_t m = mm;
|
||||
uint64_t y = 1;
|
||||
|
||||
while (e > 1) {
|
||||
if (e % 2) {
|
||||
y *= x;
|
||||
e -= 1;
|
||||
y = y % m;
|
||||
}
|
||||
x *= x;
|
||||
e /= 2;
|
||||
x = x % m;
|
||||
}
|
||||
return (uint32_t)(x * y % m);
|
||||
}
|
||||
|
||||
bool is_prime(uint32_t n, uint32_t k_max, int fd) {
|
||||
uint32_t a = get_random_bytes(fd);
|
||||
uint32_t d = n - 1;
|
||||
uint32_t s = 0;
|
||||
|
||||
while ((d & 1) == 0) {
|
||||
s++;
|
||||
d = d >> 1;
|
||||
}
|
||||
|
||||
for (uint32_t k = 0; k < k_max; k++) {
|
||||
while (a < 2 || a > (n - 2)) {
|
||||
a = get_random_bytes(fd);
|
||||
}
|
||||
uint32_t x = pow_mod(a, d, n);
|
||||
uint32_t y;
|
||||
for (uint32_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;
|
||||
}
|
||||
|
||||
uint32_t generate_prime_fd(int fd) {
|
||||
uint32_t n = get_random_bytes(fd);
|
||||
n |= 1 << 31;
|
||||
n |= 1;
|
||||
|
||||
while (n % 65537 == 0 || !is_prime(n, 128, fd)) {
|
||||
n = get_random_bytes(fd);
|
||||
n |= 1 << 31;
|
||||
n |= 1;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
uint32_t generate_prime() {
|
||||
int fd = open("/dev/urandom", O_RDONLY);
|
||||
uint32_t n = generate_prime_fd(fd);
|
||||
close(fd);
|
||||
return n;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include "rsa.h"
|
||||
|
||||
rsa_t rsa_init(size_t len, bigint_t *primes) {
|
||||
rsa_t rsa;
|
||||
|
||||
printf("Generating two primes of length %d bits\n", RSA_BLOCK_SIZE / 2);
|
||||
//printf("Generating p...\n");
|
||||
rsa.p = bigint_prime(len / 2, primes);
|
||||
printf("p = %lu\n", ((uint64_t)rsa.p.data[1] << 32) + (uint64_t)rsa.p.data[0]);
|
||||
//printf("p = %u\n", rsa.p.data[0]);
|
||||
//printf("Generating q...\n");
|
||||
rsa.q = bigint_prime(len / 2, primes);
|
||||
printf("q = %lu\n", ((uint64_t)rsa.q.data[1] << 32) + (uint64_t)rsa.q.data[0]);
|
||||
//printf("q = %u\n", rsa.q.data[0]);
|
||||
|
||||
|
||||
return rsa;
|
||||
}
|
||||
|
||||
rsa_t rsa_generate_keys(size_t block_size) {
|
||||
size_t len = block_size / sizeof(uint32_t) / 8;
|
||||
bigint_t *primes = (bigint_t *)protected_malloc(3245 * sizeof(bigint_t));
|
||||
for (int i = 0; i < 3245; i++) {
|
||||
primes[i] = bigint_zero(len);
|
||||
}
|
||||
int fd = open("primes.0000", O_RDONLY);
|
||||
char *buf = (char *)malloc(21290 * sizeof(char));
|
||||
int ret = read(fd, buf, 21290);
|
||||
char *tok = strtok(buf, "\n");
|
||||
int i = 0;
|
||||
while (tok) {
|
||||
primes[i].data[0] = (uint32_t)atoi(tok);
|
||||
tok = strtok(NULL, "\n");
|
||||
i += 1;
|
||||
}
|
||||
primes[0].data[0] = 65537;
|
||||
printf("ret %d\n", ret);
|
||||
|
||||
rsa_t rsa = rsa_init(len, primes);
|
||||
bigint_destroy(rsa.p);
|
||||
bigint_destroy(rsa.q);
|
||||
|
||||
for (int i = 0; i < 100; i++) {
|
||||
printf("%u\n", generate_prime());
|
||||
}
|
||||
|
||||
return rsa;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#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(size_t block_size);
|
||||
|
||||
|
||||
void bigint_set_random_bytes(bigint_t n, size_t len);
|
||||
void bigint_set_msb_and_lsb_to_one(bigint_t n, size_t len);
|
||||
void bigint_bitwise_left_shift(bigint_t n);
|
||||
void bigint_bitwise_right_shift(bigint_t n);
|
||||
void bigint_decrement(bigint_t n);
|
||||
int64_t bigint_cmp(bigint_t a, bigint_t b);
|
||||
bigint_t bigint_prime(size_t len, bigint_t *primes);
|
||||
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);
|
||||
void bigint_add(bigint_t a, bigint_t b);
|
||||
void custom_bigint_add(bigint_t a, bigint_t b, int index);
|
||||
bigint_t assignable_bigint_mul(bigint_t a, bigint_t b);
|
||||
bigint_t assignable_bigint_modulo(bigint_t a, bigint_t b);
|
||||
bigint_t assignable_bigint_pow_mod(bigint_t a, bigint_t e, bigint_t n);
|
||||
void bigint_set_zeros(bigint_t n);
|
||||
|
||||
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);
|
||||
|
||||
uint32_t generate_prime();
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -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;
|
||||
}
|
||||
Loading…
Reference in New Issue