From: miha-q <> Date: Wed, 9 Aug 2023 02:42:04 +0000 (-0400) Subject: Tue Aug 8 10:42:04 PM EDT 2023 X-Git-Url: http://www.foleosoft.com/?a=commitdiff_plain;h=83572733c4dfb567bee38b3c651229c3e039b289;p=CryptoFoleo.git Tue Aug 8 10:42:04 PM EDT 2023 --- diff --git a/bin/CryptoFoleo.h b/bin/CryptoFoleo.h index 9575e5e..a32b714 100644 --- a/bin/CryptoFoleo.h +++ b/bin/CryptoFoleo.h @@ -1,27 +1,28 @@ #include #include -uint8_t* chacha20(uint8_t[32], uint8_t[12], uint32_t, uint64_t); -uint8_t* chacha20_poly1305(uint8_t[32], uint8_t[12], uint8_t*, uint64_t); -uint8_t* dhke(uint8_t*, uint8_t*); -uint8_t* dhke_prf(uint32_t, uint8_t*, uint32_t, uint8_t*, uint32_t, uint8_t*, uint32_t); -uint8_t* poly1305(uint8_t*, uint8_t*, uint8_t*, uint64_t); -uint8_t* prigen(uint16_t); -#define RSA_NONE 99 -#define RSA_ENCRYPTION 1 -#define RSA_SIGNATURE 2 -#define RSA_OAEP 3 -#define RSA_PSS 4 +uint8_t* foleo_chacha20(uint8_t[32], uint8_t[12], uint32_t, uint64_t); +uint8_t* foleo_chacha20_poly1305(uint8_t[32], uint8_t[12], uint8_t*, uint64_t); +uint8_t* foleo_dhke(uint8_t*, uint8_t*); +uint8_t* foleo_dhke_prf(uint32_t, uint8_t*, uint32_t, uint8_t*, uint32_t, uint8_t*, uint32_t); +uint8_t* foleo_poly1305(uint8_t*, uint8_t*, uint8_t*, uint64_t); +static uint8_t* foleo_prigen(uint16_t); +#define FOLEO_RSA_NONE 99 +#define FOLEO_RSA_ENCRYPTION 1 +#define FOLEO_RSA_SIGNATURE 2 +#define FOLEO_RSA_OAEP 3 +#define FOLEO_RSA_PSS 4 typedef struct { mpz_t n, k; uint16_t bitWidth; } rsakey_t; -rsakey_t rsa_public(uint8_t*, uint16_t, uint8_t*, uint16_t, uint8_t*, uint16_t); -rsakey_t rsa_private(uint8_t*, uint16_t, uint8_t*, uint16_t, uint8_t*, uint16_t); -rsakey_t rsa_import(uint8_t*, uint16_t, uint8_t*, uint16_t); -uint8_t* rsa_export(rsakey_t, uint8_t, uint16_t*); -void rsa_free(rsakey_t); -uint8_t* rsa_encrypt(rsakey_t, uint8_t, uint8_t*, uint16_t); -uint8_t* rsa_decrypt(rsakey_t, uint8_t, uint8_t*, uint16_t*); -uint8_t* sha256(uint8_t*, uint32_t); +rsakey_t foleo_rsa_public(uint8_t*, uint16_t, uint8_t*, uint16_t, uint8_t*, uint16_t); +rsakey_t foleo_rsa_private(uint8_t*, uint16_t, uint8_t*, uint16_t, uint8_t*, uint16_t); +rsakey_t foleo_rsa_import(uint8_t*, uint16_t, uint8_t*, uint16_t); +uint8_t* foleo_rsa_export(rsakey_t, uint8_t, uint16_t*); +void foleo_rsa_free(rsakey_t); +uint8_t* foleo_rsa_encrypt(rsakey_t, uint8_t, uint8_t*, uint16_t); +uint8_t* foleo_rsa_decrypt(rsakey_t, uint8_t, uint8_t*, uint16_t*); +uint8_t* foleo_sha256(uint8_t*, uint32_t); +#define FOLEO_SHA256 foleo_sha256, 32, 64 diff --git a/bin/libCryptoFoleo.so b/bin/libCryptoFoleo.so index ed3cbce..6b353e5 100755 Binary files a/bin/libCryptoFoleo.so and b/bin/libCryptoFoleo.so differ diff --git a/bin/test b/bin/test index 97110b4..88de3ff 100755 Binary files a/bin/test and b/bin/test differ diff --git a/build.sh b/build.sh index 505f9ed..0b2e461 100644 --- a/build.sh +++ b/build.sh @@ -1,6 +1,8 @@ if [ "$1" == "test" ] then gcc tests/test.c -o bin/test -lgmp -DDEVICE='"/dev/random"' + bin/test + rm bin/test else gcc -shared -fPIC src/all.c -o bin/libCryptoFoleo.so -lgmp -DDEVICE='"/dev/random"' cp src/headers.h bin/CryptoFoleo.h diff --git a/private.key b/private.key new file mode 100644 index 0000000..6aba7e0 --- /dev/null +++ b/private.key @@ -0,0 +1,28 @@ ++-------[RSA Private Key]--------+ +|.*e%x/s*=$,)e%e<.*})%!`&%@.^_/`]| +|'`x%>'(!$?#<>)?)s#*":"{#*!)`/}\`| +|e)<&'!@x/&]!x,:x#}%^.;=!%&[ss<.#| +|ss%[`#=~;&?#;}>]);&%,&)##"@=(>,(;;[.,#s&e&}xs*| +|/^){\[.%}x:@#e&e,_@&?}!,*#!"="_%| +|?]#!;%*^(,e^!(()`:?$,(?*=[."#;,?| +|}`#<%,@<=se,;._e&].&~_/~@^xxx#]>| +|<@?/"_^=^{^'({~>=}(>~='%}.$e(_:#| +|^e@s,_[}=(;;?%%&[.`%s"}:s>_x):`e| +|@x'=s$="_,s\~*/.[?%,(&=()x=`=;#&| +|]?{,:~](<~;""}*^?}#^*@'`~*)#``&^| +|'x#>]=x~$@/\s`e*,,)!`}<%? @;"_&&| +|=e>@e<{>ss`xx{;:[,(:}:(,(| +|.?^@<@%`>?^&`(?{'s?~x>e`x~$_(#s'| +|=;]>e/x$@\$:?>{~)'"{(>*"e]}""x=[:=&"[]?)^)*:x/e:~%\[]{_?_~]#| +|''];'%.:*~@s{(_^x*":~}{((^&^)},;| +|.#[*[#?=:#:"`@e}/$%!=\"'s,?%s^`^| +|#\$})?x<(e:%*])@#}~"?/@{!\s%e*![| +|>;<(,%'#{]#*;@<({:!)\(`%}~#?]?')| +|=/e]^!se~@<@_>}/,[`'?/e<<&>&[=s| +|x)&&[>;&.*s*;'=e"{;! | ++--------------------------------+ diff --git a/public.key b/public.key new file mode 100644 index 0000000..5b1a4a2 --- /dev/null +++ b/public.key @@ -0,0 +1,15 @@ ++--------[RSA Public Key]--------+ +|(x({& @;"_&&=e>@e<{>ss`xx| +|{;:[,(:}:(,(.?^@<@%`>?^&`(?{'s?~| +|x>e`x~$_(#s'=;]>e/x$@\$:?>{~)'"{| +|(>*"e]}""x=[:=&"[]?)^)*:x/e:| +|~%\[]{_?_~]#''];'%.:*~@s{(_^x*":| +|~}{((^&^)},;.#[*[#?=:#:"`@e}/$%!| +|=\"'s,?%s^`^#\$})?x<(e:%*])@#}~"| +|?/@{!\s%e*![>;<(,%'#{]#*;@<({:!)| +|\(`%}~#?]?')=/e]^!se~@<@_>}/,[`| +|'?/e<<&>&[=sx)&&[>;&.*s*;'=e"{;!| ++--------------------------------+ diff --git a/src/headers.h b/src/headers.h index 03d65e7..dc6dd2f 100644 --- a/src/headers.h +++ b/src/headers.h @@ -6,7 +6,7 @@ uint8_t* foleo_chacha20_poly1305(uint8_t[32], uint8_t[12], uint8_t*, uint64_t); uint8_t* foleo_dhke(uint8_t*, uint8_t*); uint8_t* foleo_dhke_prf(uint32_t, uint8_t*, uint32_t, uint8_t*, uint32_t, uint8_t*, uint32_t); uint8_t* foleo_poly1305(uint8_t*, uint8_t*, uint8_t*, uint64_t); -uint8_t* foleo_prigen(uint16_t); +static uint8_t* foleo_prigen(uint16_t); #define FOLEO_RSA_NONE 99 #define FOLEO_RSA_ENCRYPTION 1 #define FOLEO_RSA_SIGNATURE 2 @@ -15,14 +15,15 @@ uint8_t* foleo_prigen(uint16_t); typedef struct { mpz_t n, k; + uint8_t* label; uint16_t bitWidth; } rsakey_t; rsakey_t foleo_rsa_public(uint8_t*, uint16_t, uint8_t*, uint16_t, uint8_t*, uint16_t); rsakey_t foleo_rsa_private(uint8_t*, uint16_t, uint8_t*, uint16_t, uint8_t*, uint16_t); -rsakey_t foleo_rsa_import(uint8_t*, uint16_t, uint8_t*, uint16_t); -uint8_t* foleo_rsa_export(rsakey_t, uint8_t, uint16_t*); +//rsakey_t foleo_rsa_import(uint8_t*, uint16_t, uint8_t*, uint16_t); +//uint8_t* foleo_rsa_export(rsakey_t, uint8_t, uint16_t*); void foleo_rsa_free(rsakey_t); uint8_t* foleo_rsa_encrypt(rsakey_t, uint8_t, uint8_t*, uint16_t); uint8_t* foleo_rsa_decrypt(rsakey_t, uint8_t, uint8_t*, uint16_t*); uint8_t* foleo_sha256(uint8_t*, uint32_t); -#define FOLEO_SHA256_PARAMETERS foleo_sha256, 32, 64 +#define FOLEO_SHA256 foleo_sha256, 32, 64 diff --git a/src/prigen.c b/src/prigen.c index 31ac240..a78187e 100644 --- a/src/prigen.c +++ b/src/prigen.c @@ -1,11 +1,11 @@ -#ifndef __PRIGEN__ -#define __PRIGEN__ +#ifndef __FOLEO_PRIGEN__ +#define __FOLEO_PRIGEN__ #include #include #include #include -static void PRIGEN_GetRandom(mpz_t n, uint16_t bytes, FILE *f) +static void FOLEO_PRIGEN_GetRandom(mpz_t n, uint16_t bytes, FILE *f) { mpz_set_ui(n, 0); for (uint16_t i = 0; i < bytes; i++) @@ -18,7 +18,7 @@ static void PRIGEN_GetRandom(mpz_t n, uint16_t bytes, FILE *f) } } -static void PRIGEN_ComputeDS(mpz_t n, mpz_t d, uint16_t *s) +static void FOLEO_PRIGEN_ComputeDS(mpz_t n, mpz_t d, uint16_t *s) { mpz_t t; mpz_init(t); @@ -35,7 +35,7 @@ static void PRIGEN_ComputeDS(mpz_t n, mpz_t d, uint16_t *s) mpz_clear(t); } -static uint8_t PRIGEN_PrimeTestOnce(mpz_t n, mpz_t d, uint16_t s, uint16_t witness) +static uint8_t FOLEO_PRIGEN_PrimeTestOnce(mpz_t n, mpz_t d, uint16_t s, uint16_t witness) { mpz_t x, m, a, two; uint8_t ret = 0; @@ -81,16 +81,16 @@ static uint8_t PRIGEN_PrimeTestOnce(mpz_t n, mpz_t d, uint16_t s, uint16_t witne return ret; } -static uint8_t PRIGEN_PrimeTest(mpz_t n) +static uint8_t FOLEO_PRIGEN_PrimeTest(mpz_t n) { mpz_t d; mpz_init(d); uint16_t s = 0; - PRIGEN_ComputeDS(n, d, &s); + FOLEO_PRIGEN_ComputeDS(n, d, &s); for (uint8_t a = 2; a < 12; a++) { - if (!PRIGEN_PrimeTestOnce(n, d, s, a)) + if (!FOLEO_PRIGEN_PrimeTestOnce(n, d, s, a)) { mpz_clear(d); return 0; @@ -101,18 +101,18 @@ static uint8_t PRIGEN_PrimeTest(mpz_t n) return 1; } -static void PRIGEN_GeneratePrime(mpz_t n, int bytes) +static void FOLEO_PRIGEN_GeneratePrime(mpz_t n, int bytes) { FILE *f = fopen(DEVICE, "r"); do { - PRIGEN_GetRandom(n, bytes, f); - } while (!PRIGEN_PrimeTest(n)); + FOLEO_PRIGEN_GetRandom(n, bytes, f); + } while (!FOLEO_PRIGEN_PrimeTest(n)); fclose(f); } /* Generate prime of X bytes */ -uint8_t* foleo_prigen(uint16_t bytes) +static uint8_t* foleo_prigen(uint16_t bytes) { uint8_t* buffer = malloc(bytes); FILE *f = fopen(DEVICE, "r"); @@ -120,8 +120,8 @@ uint8_t* foleo_prigen(uint16_t bytes) mpz_init(n); do { - PRIGEN_GetRandom(n, bytes, f); - } while (!PRIGEN_PrimeTest(n)); + FOLEO_PRIGEN_GetRandom(n, bytes, f); + } while (!FOLEO_PRIGEN_PrimeTest(n)); mpz_export(buffer, NULL, 1, 1, 0, 0, n); mpz_clear(n); fclose(f); diff --git a/src/rsa.c b/src/rsa.c index 497c918..6c5b8ca 100644 --- a/src/rsa.c +++ b/src/rsa.c @@ -92,42 +92,375 @@ rsakey_t foleo_rsa_private(uint8_t* p, uint16_t pS, uint8_t* q, uint16_t qS, uin return ret; } -uint8_t* foleo_rsa_export(rsakey_t key, uint8_t whichone, uint16_t* newsize) +static uint8_t foleo_rsa_prettymap(uint8_t in, uint8_t dir) { - uint8_t* ret = malloc(key.bitWidth / 8); - switch (whichone) - { - case 'd': - case 'D': - case 'e': - case 'E': - foleo_rsa_store(key.k, ret, key.bitWidth / 8); - *newsize = key.bitWidth / 8; - return ret; - case 'n': - case 'N': - foleo_rsa_store(key.n, ret, key.bitWidth / 8); - *newsize = key.bitWidth / 8; - return ret; - } - *newsize = 0; - free(ret); - return NULL; + if (dir) + { + switch (in) + { + case '_': return 0; + case '!': return 1; + case '@': return 2; + case '#': return 3; + case '$': return 4; + case '%': return 5; + case '^': return 6; + case '&': return 7; + case '*': return 8; + case '(': return 9; + case ')': return 10; + case 's': return 11; + case '~': return 12; + case 'e': return 13; + case '=': return 14; + case '`': return 15; + case '[': return 16; + case ']': return 17; + case '\\': return 18; + case ';': return 19; + case '\'': return 20; + case ',': return 21; + case '.': return 22; + case '/': return 23; + case '{': return 24; + case '}': return 25; + case 'x': return 26; + case ':': return 27; + case '"': return 28; + case '<': return 29; + case '>': return 30; + case '?': return 31; + } + return 0xFF; + } + else + { + switch (in) + { + case 0: return '_'; + case 1: return '!'; + case 2: return '@'; + case 3: return '#'; + case 4: return '$'; + case 5: return '%'; + case 6: return '^'; + case 7: return '&'; + case 8: return '*'; + case 9: return '('; + case 10: return ')'; + case 11: return 's'; + case 12: return '~'; + case 13: return 'e'; + case 14: return '='; + case 15: return '`'; + case 16: return '['; + case 17: return ']'; + case 18: return '\\'; + case 19: return ';'; + case 20: return '\''; + case 21: return ','; + case 22: return '.'; + case 23: return '/'; + case 24: return '{'; + case 25: return '}'; + case 26: return 'x'; + case 27: return ':'; + case 28: return '"'; + case 29: return '<'; + case 30: return '>'; + case 31: return '?'; + } + } } -rsakey_t foleo_rsa_import(uint8_t* bufferK, uint16_t byteSizeK, uint8_t* bufferN, uint16_t byteSizeN) +static rsakey_t foleo_rsa_import(uint8_t* buf) { - rsakey_t ret; - ret.bitWidth = byteSizeN * 8; - mpz_init(ret.k); - mpz_init(ret.n); - mpz_set_ui(ret.k, 0); - mpz_set_ui(ret.n, 0); + rsakey_t k; + mpz_init(k.k); + mpz_init(k.n); + mpz_set_ui(k.k, 0); + mpz_set_ui(k.n, 0); + k.label = malloc(0); + uint32_t lblS = 0; + uint32_t i; + uint8_t state = 0; + uint32_t bitWidth = 0; + for (uint32_t i = 0; buf[i] != 0; i++) + { + if (state == 0) + { + if (buf[i] == '[') state = 1; + if (buf[i] == '\n') state = 2; + } + else if (state == 1) + { + if (buf[i] == ']') + { + state = 2; + k.label = realloc(k.label, lblS + 1); + k.label[lblS] = 0; + } + else + { + k.label = realloc(k.label, lblS + 1); + k.label[lblS++] = buf[i]; + } + } + else if (state == 2) + { + if (buf[i] == ' ') state = 3; + else if (foleo_rsa_prettymap(buf[i], 1) != 0xFF) + { + mpz_mul_ui(k.k, k.k, 32); + mpz_add_ui(k.k, k.k, foleo_rsa_prettymap(buf[i], 1)); + bitWidth += 1; + } + } + else if (state == 3) + { + if (buf[i] == ' ') break; + else if (foleo_rsa_prettymap(buf[i], 1) != 0xFF) + { + mpz_mul_ui(k.n, k.n, 32); + mpz_add_ui(k.n, k.n, foleo_rsa_prettymap(buf[i], 1)); + } + } + } + k.bitWidth = mpz_sizeinbase(k.n, 2); + if (k.bitWidth % 8 != 0) + { + k.bitWidth = (k.bitWidth + 1) % 8 == 0 ? k.bitWidth + 1 : k.bitWidth - 1; + while (k.bitWidth % 8 != 0) k.bitWidth++; + } + return k; +} - foleo_rsa_load(ret.k, bufferK, byteSizeK); - foleo_rsa_load(ret.n, bufferN, byteSizeN); - - return ret; +static uint8_t* foleo_rsa_export(rsakey_t k) +{ + const uint8_t width = 32; + mpz_t n, t; + mpz_init(n); + mpz_init(t); + mpz_set(n, k.n); + uint8_t* kn = malloc(0); + uint16_t knS = 0; + while (mpz_sgn(n) != 0) + { + mpz_mod_ui(t, n, 32); + kn = realloc(kn, knS + 1); + kn[knS++] = foleo_rsa_prettymap(mpz_get_ui(t), 0); + mpz_div_ui(n, n, 32); + } + mpz_set(n, k.k); + uint8_t* kk = malloc(0); + uint16_t kkS = 0; + while (mpz_sgn(n) != 0) + { + mpz_mod_ui(t, n, 32); + kk = realloc(kk, kkS + 1); + kk[kkS++] = foleo_rsa_prettymap(mpz_get_ui(t), 0); + mpz_div_ui(n, n, 32); + } + + uint8_t* keyascii = malloc(0); + uint32_t keyascii_i = 0; + uint32_t cnt = 0; + + uint8_t nolabel = 0; + if (k.label == NULL) + { + nolabel = 1; + } + else if (k.label[0] == 0) + { + nolabel = 1; + } + + keyascii = realloc(keyascii, keyascii_i + 1); + keyascii[keyascii_i++] = '+'; + if (nolabel) + { + for (uint32_t i = 0; i < width; i++) + { + keyascii = realloc(keyascii, keyascii_i + 1); + keyascii[keyascii_i++] = '-'; + } + } + else + { + uint8_t* tmsg = malloc(1); + tmsg[0] = '['; + uint32_t li = 0; + uint32_t mS = 1; + for (;;) + { + tmsg = realloc(tmsg, mS + 1); + tmsg[mS++] = k.label[li++]; + if (k.label[li] == 0 || mS > (width / 3) * 2) + { + tmsg = realloc(tmsg, mS + 2); + tmsg[mS++] = ']'; + break; + } + } + uint32_t m0 = (width / 2) - ((mS - 1) / 2) - 1; + uint32_t m1 = m0 + mS; + for (uint32_t i = 0; i < width; i++) + { + keyascii = realloc(keyascii, keyascii_i + 1); + if (i >= m0 && i < m1) + { + keyascii[keyascii_i++] = tmsg[i - m0]; + } + else + { + keyascii[keyascii_i++] = '-'; + } + } + free(tmsg); + } + keyascii = realloc(keyascii, keyascii_i + 3); + keyascii[keyascii_i++] = '+'; + keyascii[keyascii_i++] = '\n'; + keyascii[keyascii_i++] = '|'; + + for (uint8_t i = 0; i < 2; i++) + { + if (i == 1) + { + keyascii = realloc(keyascii, keyascii_i + 1); + keyascii[keyascii_i++] = ' '; + mpz_set(n, k.n); + cnt++; + if (cnt % width == 0) + { + keyascii = realloc(keyascii, keyascii_i + 3); + keyascii[keyascii_i++] = '|'; + keyascii[keyascii_i++] = '\n'; + keyascii[keyascii_i++] = '|'; + cnt = 0; + } + } + for (uint16_t j = 0; j < (i == 0 ? kkS : knS); j++) + { + keyascii = realloc(keyascii, keyascii_i + 1); + keyascii[keyascii_i++] = i == 0 ? kk[kkS - j - 1] : kn[knS - j - 1]; + cnt++; + if (cnt % width == 0) + { + keyascii = realloc(keyascii, keyascii_i + 3); + keyascii[keyascii_i++] = '|'; + keyascii[keyascii_i++] = '\n'; + keyascii[keyascii_i++] = '|'; + cnt = 0; + } + } + } + free(kn); + free(kk); + mpz_clear(n); + mpz_clear(t); + + if (cnt % width == 0) + { + keyascii[keyascii_i - 1] = '+'; + } + else + { + while (cnt % width != 0) + { + keyascii = realloc(keyascii, keyascii_i + 1); + keyascii[keyascii_i++] = ' '; + cnt++; + } + keyascii = realloc(keyascii, keyascii_i + 3); + keyascii[keyascii_i++] = '|'; + keyascii[keyascii_i++] = '\n'; + keyascii[keyascii_i++] = '+'; + } + for (uint32_t i = 0; i < width; i++) + { + keyascii = realloc(keyascii, keyascii_i + 1); + keyascii[keyascii_i++] = '-'; + } + keyascii = realloc(keyascii, keyascii_i + 3); + keyascii[keyascii_i++] = '+'; + keyascii[keyascii_i++] = '\n'; + keyascii[keyascii_i++] = 0; + return keyascii; +} + +void foleo_rsa_keygen(uint16_t bitWidth, rsakey_t* public, rsakey_t* private) +{ + if (bitWidth < 64) + { + fprintf(stderr, "foleo_rsa_keygen(): Do not use a bit-width smaller than 64.\n"); + exit(1); + } + + uint8_t* p = foleo_prigen(bitWidth / 16); + uint8_t* q = foleo_prigen(bitWidth / 16); + uint8_t* e = foleo_prigen(3); + mpz_init(public->n); + mpz_init(public->k); + mpz_init(private->n); + mpz_init(private->k); + + mpz_t np, nq; + mpz_init(np); + mpz_init(nq); + foleo_rsa_load(np, p, bitWidth / 16); + foleo_rsa_load(nq, q, bitWidth / 16); + foleo_rsa_load(public->k, e, 3); + public->bitWidth = bitWidth; + private->bitWidth = bitWidth; + mpz_mul(public->n, np, nq); + mpz_set(private->n, public->n); + mpz_sub_ui(np, np, 1); + mpz_sub_ui(nq, nq, 1); + mpz_mul(np, np, nq); + mpz_invert(private->k, public->k, np); + + mpz_clear(np); + mpz_clear(nq); + free(p); + free(q); + free(e); + + public->label = malloc(15); + public->label[ 0] = 'R'; + public->label[ 1] = 'S'; + public->label[ 2] = 'A'; + public->label[ 3] = ' '; + public->label[ 4] = 'P'; + public->label[ 5] = 'u'; + public->label[ 6] = 'b'; + public->label[ 7] = 'l'; + public->label[ 8] = 'i'; + public->label[ 9] = 'c'; + public->label[10] = ' '; + public->label[11] = 'K'; + public->label[12] = 'e'; + public->label[13] = 'y'; + public->label[14] = 0; + + private->label = malloc(16); + private->label[ 0] = 'R'; + private->label[ 1] = 'S'; + private->label[ 2] = 'A'; + private->label[ 3] = ' '; + private->label[ 4] = 'P'; + private->label[ 5] = 'r'; + private->label[ 6] = 'i'; + private->label[ 7] = 'v'; + private->label[ 8] = 'a'; + private->label[ 9] = 't'; + private->label[10] = 'e'; + private->label[11] = ' '; + private->label[12] = 'K'; + private->label[13] = 'e'; + private->label[14] = 'y'; + private->label[15] = 0; } void foleo_rsa_free(rsakey_t key) @@ -135,6 +468,7 @@ void foleo_rsa_free(rsakey_t key) key.bitWidth = -1; mpz_clear(key.n); mpz_clear(key.k); + if (key.label != NULL) free(key.label); } //convert to PKCS#1 v1.5 encryption block @@ -143,8 +477,9 @@ void foleo_rsa_free(rsakey_t key) static uint8_t* FOLEO_RSA_Pad(uint16_t size, uint8_t* buffer, uint16_t bufferSizeInBytes) { size /= 8; - if (bufferSizeInBytes - 11 > size) + if (bufferSizeInBytes > size - 11) { + fprintf(stderr, "foleo_rsa_encrypt(): Message size too large to pad!\n"); return NULL; } uint8_t* block = malloc(size); @@ -215,8 +550,9 @@ static uint8_t* FOLEO_RSA_DePad(uint16_t size, uint8_t* block, uint16_t* bufferS static uint8_t* FOLEO_RSA_PadSig(uint16_t size, uint8_t* buffer, uint16_t bufferSizeInBytes) { size /= 8; - if (bufferSizeInBytes - 11 > size) + if (bufferSizeInBytes > size - 11) { + fprintf(stderr, "foleo_rsa_encrypt(): Message size too large to pad!\n"); return NULL; } uint8_t* block = malloc(size); @@ -287,8 +623,9 @@ static uint8_t* FOLEO_RSA_PadOAEP(uint16_t size, uint8_t* buffer, uint16_t mLen) uint32_t mmLen = kLen - 2 * hLen - 2; //maximum message length uint32_t psLen = kLen - mLen - 2 * hLen - 2; //padding string length uint32_t dbLen = hLen + psLen + 1 + mLen; //datablock length - if (mLen > mmLen) + if (mLen > mmLen || mmLen > 1000) { + fprintf(stderr, "foleo_rsa_encrypt(): Message size too large to pad with OAEP!\n"); return NULL; } @@ -394,6 +731,11 @@ uint8_t* foleo_rsa_encrypt(rsakey_t key, uint8_t padding, uint8_t* buffer, uint1 } else { + if (bufferSize >= key.bitWidth / 8) + { + fprintf(stderr, "foleo_rsa_encrypt(): Message size too large for the modulus!\n"); + return NULL; + } eblock = FOLEO_RSA_Apply(key, buffer); } return eblock; @@ -421,4 +763,19 @@ uint8_t* foleo_rsa_decrypt(rsakey_t key, uint8_t padding, uint8_t* eblock, uint1 } return buffer; } + +//calculate the usable block size +uint16_t foleo_rsa_size(rsakey_t key, uint8_t padding) +{ + if (padding == FOLEO_RSA_ENCRYPTION || padding == FOLEO_RSA_SIGNATURE) + { + return (key.bitWidth / 8) - 11; + } + if (padding = FOLEO_RSA_OAEP) + { + return (key.bitWidth / 8) - 2 * 32 - 2; //sha-256 + } + return key.bitWidth / 8; +} + #endif diff --git a/tests/test.c b/tests/test.c index 753b811..25442f0 100644 --- a/tests/test.c +++ b/tests/test.c @@ -1,5 +1,6 @@ #include "../src/all.c" #include "cases.c" +#include void test_pbuf(char* p, uint8_t* b, uint32_t s) { @@ -15,7 +16,7 @@ void test_hmac(uint8_t grp, uint16_t id, uint8_t key[], uint16_t keyS, uint8_t d { uint8_t lbl1[] = " NIST"; uint8_t lbl2[] = "RCF#4231"; - uint8_t* out = foleo_hmac(foleo_sha256, 32, 64, key, keyS, data, dataS); + uint8_t* out = foleo_hmac(FOLEO_SHA256, key, keyS, data, dataS); for (uint16_t i = 0; i < resultS; i++) { if (out[i] != result[i]) @@ -31,7 +32,7 @@ void test_hmac(uint8_t grp, uint16_t id, uint8_t key[], uint16_t keyS, uint8_t d void test_hkdf(uint16_t id, uint8_t* ikm, uint32_t ikmS, uint8_t* salt, uint32_t saltS, uint8_t* info, uint32_t infoS, uint8_t* result, uint32_t resultS) { - uint8_t* out = foleo_hmac_hkdf(FOLEO_SHA256_PARAMETERS, resultS, ikm, ikmS, salt, saltS, info, infoS); + uint8_t* out = foleo_hmac_hkdf(FOLEO_SHA256, resultS, ikm, ikmS, salt, saltS, info, infoS); for (uint16_t i = 0; i < resultS; i++) { if (out[i] != result[i]) @@ -47,20 +48,51 @@ void test_hkdf(uint16_t id, uint8_t* ikm, uint32_t ikmS, uint8_t* salt, uint32_t void main() { - test_hmac(1, 1, NIST_HMAC_key1, sizeof(NIST_HMAC_key1), NIST_HMAC_data1, sizeof(NIST_HMAC_data1), NIST_HMAC_result1, sizeof(NIST_HMAC_result1)); - test_hmac(1, 2, NIST_HMAC_key2, sizeof(NIST_HMAC_key2), NIST_HMAC_data2, sizeof(NIST_HMAC_data2), NIST_HMAC_result2, sizeof(NIST_HMAC_result2)); - test_hmac(1, 3, NIST_HMAC_key3, sizeof(NIST_HMAC_key3), NIST_HMAC_data3, sizeof(NIST_HMAC_data3), NIST_HMAC_result3, sizeof(NIST_HMAC_result3)); - test_hmac(1, 4, NIST_HMAC_key4, sizeof(NIST_HMAC_key4), NIST_HMAC_data4, sizeof(NIST_HMAC_data4), NIST_HMAC_result4, sizeof(NIST_HMAC_result4)); - test_hmac(2, 1, RFC4231_HMAC_key1, sizeof(RFC4231_HMAC_key1), RFC4231_HMAC_data1, sizeof(RFC4231_HMAC_data1), RFC4231_HMAC_result1, sizeof(RFC4231_HMAC_result1)); - test_hmac(2, 2, RFC4231_HMAC_key2, sizeof(RFC4231_HMAC_key2), RFC4231_HMAC_data2, sizeof(RFC4231_HMAC_data2), RFC4231_HMAC_result2, sizeof(RFC4231_HMAC_result2)); - test_hmac(2, 3, RFC4231_HMAC_key3, sizeof(RFC4231_HMAC_key3), RFC4231_HMAC_data3, sizeof(RFC4231_HMAC_data3), RFC4231_HMAC_result3, sizeof(RFC4231_HMAC_result3)); - test_hmac(2, 4, RFC4231_HMAC_key4, sizeof(RFC4231_HMAC_key4), RFC4231_HMAC_data4, sizeof(RFC4231_HMAC_data4), RFC4231_HMAC_result4, sizeof(RFC4231_HMAC_result4)); - test_hmac(2, 5, RFC4231_HMAC_key5, sizeof(RFC4231_HMAC_key5), RFC4231_HMAC_data5, sizeof(RFC4231_HMAC_data5), RFC4231_HMAC_result5, sizeof(RFC4231_HMAC_result5)); - test_hmac(2, 6, RFC4231_HMAC_key6, sizeof(RFC4231_HMAC_key6), RFC4231_HMAC_data6, sizeof(RFC4231_HMAC_data6), RFC4231_HMAC_result6, sizeof(RFC4231_HMAC_result6)); - test_hmac(2, 7, RFC4231_HMAC_key7, sizeof(RFC4231_HMAC_key7), RFC4231_HMAC_data7, sizeof(RFC4231_HMAC_data7), RFC4231_HMAC_result7, sizeof(RFC4231_HMAC_result7)); + //test_hmac(1, 1, NIST_HMAC_key1, sizeof(NIST_HMAC_key1), NIST_HMAC_data1, sizeof(NIST_HMAC_data1), NIST_HMAC_result1, sizeof(NIST_HMAC_result1)); + //test_hmac(1, 2, NIST_HMAC_key2, sizeof(NIST_HMAC_key2), NIST_HMAC_data2, sizeof(NIST_HMAC_data2), NIST_HMAC_result2, sizeof(NIST_HMAC_result2)); + //test_hmac(1, 3, NIST_HMAC_key3, sizeof(NIST_HMAC_key3), NIST_HMAC_data3, sizeof(NIST_HMAC_data3), NIST_HMAC_result3, sizeof(NIST_HMAC_result3)); + //test_hmac(1, 4, NIST_HMAC_key4, sizeof(NIST_HMAC_key4), NIST_HMAC_data4, sizeof(NIST_HMAC_data4), NIST_HMAC_result4, sizeof(NIST_HMAC_result4)); + //test_hmac(2, 1, RFC4231_HMAC_key1, sizeof(RFC4231_HMAC_key1), RFC4231_HMAC_data1, sizeof(RFC4231_HMAC_data1), RFC4231_HMAC_result1, sizeof(RFC4231_HMAC_result1)); + //test_hmac(2, 2, RFC4231_HMAC_key2, sizeof(RFC4231_HMAC_key2), RFC4231_HMAC_data2, sizeof(RFC4231_HMAC_data2), RFC4231_HMAC_result2, sizeof(RFC4231_HMAC_result2)); + //test_hmac(2, 3, RFC4231_HMAC_key3, sizeof(RFC4231_HMAC_key3), RFC4231_HMAC_data3, sizeof(RFC4231_HMAC_data3), RFC4231_HMAC_result3, sizeof(RFC4231_HMAC_result3)); + //test_hmac(2, 4, RFC4231_HMAC_key4, sizeof(RFC4231_HMAC_key4), RFC4231_HMAC_data4, sizeof(RFC4231_HMAC_data4), RFC4231_HMAC_result4, sizeof(RFC4231_HMAC_result4)); + //test_hmac(2, 5, RFC4231_HMAC_key5, sizeof(RFC4231_HMAC_key5), RFC4231_HMAC_data5, sizeof(RFC4231_HMAC_data5), RFC4231_HMAC_result5, sizeof(RFC4231_HMAC_result5)); + //test_hmac(2, 6, RFC4231_HMAC_key6, sizeof(RFC4231_HMAC_key6), RFC4231_HMAC_data6, sizeof(RFC4231_HMAC_data6), RFC4231_HMAC_result6, sizeof(RFC4231_HMAC_result6)); + //test_hmac(2, 7, RFC4231_HMAC_key7, sizeof(RFC4231_HMAC_key7), RFC4231_HMAC_data7, sizeof(RFC4231_HMAC_data7), RFC4231_HMAC_result7, sizeof(RFC4231_HMAC_result7)); +// + //test_hkdf(1, RFC5869_HKDF_ikm1, sizeof(RFC5869_HKDF_ikm1), RFC5869_HKDF_salt1, sizeof(RFC5869_HKDF_salt1), RFC5869_HKDF_info1, sizeof(RFC5869_HKDF_info1), RFC5869_HKDF_result1, sizeof(RFC5869_HKDF_result1)); + //test_hkdf(2, RFC5869_HKDF_ikm2, sizeof(RFC5869_HKDF_ikm2), RFC5869_HKDF_salt2, sizeof(RFC5869_HKDF_salt2), RFC5869_HKDF_info2, sizeof(RFC5869_HKDF_info2), RFC5869_HKDF_result2, sizeof(RFC5869_HKDF_result2)); + //test_hkdf(3, RFC5869_HKDF_ikm3, sizeof(RFC5869_HKDF_ikm3), RFC5869_HKDF_salt3, sizeof(RFC5869_HKDF_salt3), RFC5869_HKDF_info3, sizeof(RFC5869_HKDF_info3), RFC5869_HKDF_result3, sizeof(RFC5869_HKDF_result3)); + + rsakey_t pub, prv; + foleo_rsa_keygen(2048, &pub, &prv); + + uint8_t* b1 = foleo_rsa_export(pub); + uint8_t* b2 = foleo_rsa_export(prv); + + foleo_rsa_free(pub); + foleo_rsa_free(prv); + pub = foleo_rsa_import(b1); + prv = foleo_rsa_import(b2); + + printf(">%i<\n", foleo_rsa_size(pub, FOLEO_RSA_ENCRYPTION)); + + uint8_t plaintext[245]; + for (uint16_t i = 0; i < sizeof(plaintext); i++) plaintext[i] = i; + uint8_t* ciphertext = foleo_rsa_encrypt(pub, FOLEO_RSA_ENCRYPTION, plaintext, sizeof(plaintext)); + uint16_t newSize; + uint8_t* newplaintext = foleo_rsa_decrypt(prv, FOLEO_RSA_ENCRYPTION, ciphertext, &newSize); + + test_pbuf("...", newplaintext, newSize); + + free(b1); + free(b2); + free(ciphertext); + free(newplaintext); + foleo_rsa_free(pub); + foleo_rsa_free(prv); + + - test_hkdf(1, RFC5869_HKDF_ikm1, sizeof(RFC5869_HKDF_ikm1), RFC5869_HKDF_salt1, sizeof(RFC5869_HKDF_salt1), RFC5869_HKDF_info1, sizeof(RFC5869_HKDF_info1), RFC5869_HKDF_result1, sizeof(RFC5869_HKDF_result1)); - test_hkdf(2, RFC5869_HKDF_ikm2, sizeof(RFC5869_HKDF_ikm2), RFC5869_HKDF_salt2, sizeof(RFC5869_HKDF_salt2), RFC5869_HKDF_info2, sizeof(RFC5869_HKDF_info2), RFC5869_HKDF_result2, sizeof(RFC5869_HKDF_result2)); - test_hkdf(3, RFC5869_HKDF_ikm3, sizeof(RFC5869_HKDF_ikm3), RFC5869_HKDF_salt3, sizeof(RFC5869_HKDF_salt3), RFC5869_HKDF_info3, sizeof(RFC5869_HKDF_info3), RFC5869_HKDF_result3, sizeof(RFC5869_HKDF_result3)); }