Tue Aug 8 10:42:04 PM EDT 2023

diff --git a/bin/CryptoFoleo.h b/bin/CryptoFoleo.h
index 9575e5eb454afd88d733ef1b6073b53ad3649054..a32b714ec08f0afb3113cbc5b561614f4bfb069a 100644 (file)
--- a/bin/CryptoFoleo.h
+++ b/bin/CryptoFoleo.h
@@ -1,27 +1,28 @@
 #include <stdint.h>
 #include <gmp.h>
 
-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 ed3cbcee1614592813d55651395f604d3072b5df..6b353e5008bbfd89c16c59c3e5cb38d58802dde2 100755 (executable)
Binary files a/bin/libCryptoFoleo.so and b/bin/libCryptoFoleo.so differ

diff --git a/bin/test b/bin/test
index 97110b4eca3919ff04c4488e9fc5c511cdfd2e80..88de3ff1f530b7ca43b3bd10c3e9b8a9aff36e3e 100755 (executable)
Binary files a/bin/test and b/bin/test differ

diff --git a/build.sh b/build.sh
index 505f9ed5cf3eaedb777afa04fed0a02e2ed46b75..0b2e46184890b6ecb65946b130143c3a9abd7adf 100644 (file)
--- 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 (file)
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%[`#=~;&?#;}>]);&<e}.~'_s,%=]'|
+|:*&&>%,&)##"@=(>,(;;[.,#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<{>s<!s~"\>s`xx{;:[,(:}:(,(|
+|.?^@<@%`>?^&`(?{'s?~x>e`x~$_(#s'|
+|=;]>e/x$@\$:?>{~)'"{(>*"e]}""x<s|
+|@~"*]}!:;/"%#?%`\=s]"/<[.//]$`[.|
+|<>=[:=&"[]?)^)*:x/e:~%\[]{_?_~]#|
+|''];'%.:*~@s{(_^x*":~}{((^&^)},;|
+|.#[*[#?=:#:"`@e}/$%!=\"'s,?%s^`^|
+|#\$})?x<(e:%*])@#}~"?/@{!\s%e*![|
+|>;<(,%'#{]#*;@<({:!)\(`%}~#?]?')|
+|=/e]^!se~@<@_>}</[s;x'#*^^'~,<x?|
+|'')=$&^='<;\{"&":@^e?e%$*~*#&:^.|
+|(@_@.]$/e`=[*//>/,[`'?/e<<&>&[=s|
+|x)&&[>;&.*s*;'=e"{;!            |
++--------------------------------+

diff --git a/public.key b/public.key
new file mode 100644 (file)
index 0000000..5b1a4a2
--- /dev/null
+++ b/public.key
@@ -0,0 +1,15 @@
++--------[RSA Public Key]--------+
+|(x({& @;"_&&=e>@e<{>s<!s~"\>s`xx|
+|{;:[,(:}:(,(.?^@<@%`>?^&`(?{'s?~|
+|x>e`x~$_(#s'=;]>e/x$@\$:?>{~)'"{|
+|(>*"e]}""x<s@~"*]}!:;/"%#?%`\=s]|
+|"/<[.//]$`[.<>=[:=&"[]?)^)*:x/e:|
+|~%\[]{_?_~]#''];'%.:*~@s{(_^x*":|
+|~}{((^&^)},;.#[*[#?=:#:"`@e}/$%!|
+|=\"'s,?%s^`^#\$})?x<(e:%*])@#}~"|
+|?/@{!\s%e*![>;<(,%'#{]#*;@<({:!)|
+|\(`%}~#?]?')=/e]^!se~@<@_>}</[s;|
+|x'#*^^'~,<x?'')=$&^='<;\{"&":@^e|
+|?e%$*~*#&:^.(@_@.]$/e`=[*//>/,[`|
+|'?/e<<&>&[=sx)&&[>;&.*s*;'=e"{;!|
++--------------------------------+

diff --git a/src/headers.h b/src/headers.h
index 03d65e7f0dbae2c5829a90fe137a5973de51a201..dc6dd2fdc6a3ab91a2726ff059ffef8b7abb01ee 100644 (file)
--- 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 31ac24054261b1c17185a949bc36494bc237a40e..a78187ee46f2dd92519a89099be4d145eb24493c 100644 (file)
--- a/src/prigen.c
+++ b/src/prigen.c
@@ -1,11 +1,11 @@
-#ifndef __PRIGEN__
-#define __PRIGEN__
+#ifndef __FOLEO_PRIGEN__
+#define __FOLEO_PRIGEN__
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <gmp.h>
 
-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 497c918fbae7cd0b5cf3e66f3de6135d6f5ff00d..6c5b8ca83f3b8568850474139965b139627d1c5d 100644 (file)
--- 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 753b811903720206d952163d45ab71d9ff04377a..25442f0857453255c41f9ee6c672f5034d0b8d45 100644 (file)
--- a/tests/test.c
+++ b/tests/test.c
@@ -1,5 +1,6 @@
 #include "../src/all.c"
 #include "cases.c"
+#include <string.h>
 
 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));
 
 }