From 89a19a171be63bf09a97c44cfb64dabd0a5ce2ad Mon Sep 17 00:00:00 2001 From: miha-q <> Date: Mon, 7 Aug 2023 00:01:24 -0400 Subject: [PATCH] Mon Aug 7 12:01:24 AM EDT 2023 --- README.md | 85 +++++++++ bin/CryptoFoleo.h | 27 +++ bin/libCryptoFoleo.so | Bin 0 -> 35584 bytes build.sh | 2 + src/all.c | 7 + src/chacha20.c | 127 +++++++++++++ src/dhke.c | 351 ++++++++++++++++++++++++++++++++++ src/headers.h | 27 +++ src/poly1305.c | 86 +++++++++ src/prigen.c | 130 +++++++++++++ src/rsa.c | 424 ++++++++++++++++++++++++++++++++++++++++++ src/sha256.c | 184 ++++++++++++++++++ tests/SHA256.pdf | Bin 0 -> 99090 bytes tests/rfc4231.txt.pdf | Bin 0 -> 12961 bytes tests/rfc7539.pdf | Bin 0 -> 65585 bytes 15 files changed, 1450 insertions(+) create mode 100644 README.md create mode 100644 bin/CryptoFoleo.h create mode 100755 bin/libCryptoFoleo.so create mode 100644 build.sh create mode 100644 src/all.c create mode 100644 src/chacha20.c create mode 100644 src/dhke.c create mode 100644 src/headers.h create mode 100644 src/poly1305.c create mode 100644 src/prigen.c create mode 100644 src/rsa.c create mode 100644 src/sha256.c create mode 100644 tests/SHA256.pdf create mode 100644 tests/rfc4231.txt.pdf create mode 100644 tests/rfc7539.pdf diff --git a/README.md b/README.md new file mode 100644 index 0000000..677534a --- /dev/null +++ b/README.md @@ -0,0 +1,85 @@ +# CryptoFoleo +A library with some basic cryptography for C and Haskell. + + uint8_t* chacha20(uint8_t[32], uint8_t[12], uint32_t, uint64_t); + +Generate a pseudorandom number mask from ChaCha20 cipher. The first parameter is the key, the second is the nonce, the third is the starting block number, and the last is the number of bytes you want to generate. If you are using this in conjunction with Poly1305, then you MUST use a starting block greater than zero. + + uint8_t* poly1305(uint8_t*, uint8_t*, uint8_t*, uint32_t); + +Generate a Poly1305 hash where the first two parameters are 16-byte starting states (r, s), the third is a pointer to the data to hash, and the last is the length of that data. A Poly1305 hash is always 16 bytes. + + uint8_t* chacha20_poly1305(uint8_t[32], uint8_t[12], uint8_t*, uint64_t); + +Generates a Poly1305 message authentication code. The first two parameters are again the key and the nonce for the ChaCha20 cipher, the second is the pointer to the message to be authenticated and the last is the length of the message. This code is again 16 bytes. + + uint8_t* dhke(uint8_t*, uint8_t*); + +Performs a Diffie-Hellman key exchange using the 4096-bit prime ID#16 located in RFC#3526. The two parameters are "private" and "public" where "private" refers to the initial randomly generated numbers and "public" refers to the computed numbers that are shared across the network. If the function is called with both options as NULL, then it will return a randomly generated "private" value that is 512 bytes in size. If that private value is then passed into the first parameter with the public parameter, the second parameter, left as NULL, then it will return the 512 public bytes that are meant to be shared over the network. If the private value is passed into the first parameter and the public value received other the network is passed into the second parameter, it will then compute the 512 byte shared secret. This one function can therefore handle the entire key exchange process. + + uint8_t* dhke_prf(uint32_t, uint8_t*, uint32_t, uint8_t*, uint32_t, uint8_t*, uint32_t); + +Because the key is 4096 bits long which may either be too much or too little +depending on your purposes, this library also offers as a way to convert the +output of the key exchange into any arbitrary number of bytes appropriate +for your purposes. This is just an implemetation of the PRF() function described in RFC#5246 using SHA-256. + +The first parameter specifies how many bytes you wish to return. If you are using a ChaCha20 cipher, this will be 32 as you will need 32-bytes for the ChaCha20 key, and thus the 512-byte shared secret will be converted into a 32-byte value. The rest of the parameters are pointers to some data followed by the number of bytes representing the size of that data. These three options are, in order, the secret, the label, and seed. The secret is the Diffie-Hellman shared secret derived at the end of the Diffie-Hellman key exchange process. The label and the seed require further explanation. + +The label should specify the kind of operation being done. It is common to not use the Diffie-Hellman output directly but instead +transform it into another shared secret by first passing it into the PRF. +Since the PRF is effectively a pseudorandom number generator, if both sides +start with the same seed, they will still derive the same secret. In this +case, the label is specified as "master secret" without a null terminator. + +This master secret is then used to derive further session keys to be used +later in the communication, and at that point PRF() is called again with +a different label "key expansion" again without the null terminator. Using +different labels for different operations makes sure you get a different +set of pseudorandom numbers per operation which both parties should agree +upon. + +The seed helps increase the unpredictability of the PRF function by +introducing additional random numbers into the starting point of the PRF() +function. Since both parties need to produce the same numbers, this seed +will have to be shared publicly, typically as part of the same handshake +where they exchange their Diffie-Hellman numbers. + + + uint8_t* prigen(uint16_t); + +Generates a random prime number. The parameter is the byte-width of the prime number. For example, if you want to generate random 1024-bit RSA keys, then you can call this twice passing in the number 128. + + rsakey_t rsa_public(uint8_t*, uint16_t, uint8_t*, uint16_t, uint8_t*, uint16_t); + +This takes three parameters: p, q, and e, and from them calculates the RSA public key. The reason there are six parameters is because after each key buffer is another parameter specifying the size of that buffer in bytes. + + rsakey_t rsa_private(uint8_t*, uint16_t, uint8_t*, uint16_t, uint8_t*, uint16_t); + +Same as above except it calculates the RSA private key. + + rsakey_t rsa_import(uint8_t*, uint16_t, uint8_t*, uint16_t); + +Imports an RSA key from a buffer. This expects you to either pass in d and n, or e and n, depending on whether or not it is a private or public key. + + uint8_t* rsa_export(rsakey_t, uint8_t, uint16_t*); + +Export an RSA key. The second parameter specifies which key you want to export. For public keys, valid options are the byte 'e' or the byte 'n'. For private keys, valid options are the byte 'd' or the byte 'n'. The last parameter will contain the size of the key in bytes, and the function returns a pointer to that key. + + void rsa_free(rsakey_t); + +Free the memory associated with an RSA key. + + uint8_t* rsa_encrypt(rsakey_t, uint8_t, uint8_t*, uint16_t); + +Encrypts some data using an RSA key. This only encrypts a single block which is why the last parameter, which specifies the size of the data you wish to encrypt, is only a 16-bit integer. If you want to encrypt many blocks of data, you will need to break your data up into blocks manually and call this for each block. The third parameter points to the buffer of data you want to encrypt. + +The second parameter is the type of padding to be used during encryption. Current supported options are RSA_ENCRYPTION which applies PKCS#1 v1.5 encryption padding, RSA_SIGNATURE which applies PKCS#1 v1.5 signature padding, and RSA_OAEP which applies optimal asymmetric encryption padding with SHA-256. You can also pass RSA_NONE into it for no padding at all. + + uint8_t* rsa_decrypt(rsakey_t, uint8_t, uint8_t*, uint16_t*); + +This will both decrypt and "de-pad" RSA ciphertext blocks. Since the size of the message could be smaller than the maximum size that could fit into the block, it also will return the message size after decryption as the last parameter. Like with encryption, you can also specify the padding type. If the padding types do not match up from what was encrypted, it will fail to decrypt, returning a NULL value. + + uint8_t* sha256(uint8_t*, uint32_t); + +Computes a SHA-256 hash with the two parameters being a pointer to the data and the size of the data to be hashed. diff --git a/bin/CryptoFoleo.h b/bin/CryptoFoleo.h new file mode 100644 index 0000000..9575e5e --- /dev/null +++ b/bin/CryptoFoleo.h @@ -0,0 +1,27 @@ +#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 +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); diff --git a/bin/libCryptoFoleo.so b/bin/libCryptoFoleo.so new file mode 100755 index 0000000000000000000000000000000000000000..22000dbf016fc7feb4e7f3bafb826d3bd340fc77 GIT binary patch literal 35584 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 literal 0 HcmV?d00001 diff --git a/build.sh b/build.sh new file mode 100644 index 0000000..abe23b5 --- /dev/null +++ b/build.sh @@ -0,0 +1,2 @@ +gcc -shared -fPIC src/all.c -o bin/libCryptoFoleo.so -lgmp -DDEVICE='"/dev/random"' +cp src/headers.h bin/CryptoFoleo.h diff --git a/src/all.c b/src/all.c new file mode 100644 index 0000000..e53019f --- /dev/null +++ b/src/all.c @@ -0,0 +1,7 @@ +#include "headers.h" +#include "chacha20.c" +#include "dhke.c" +#include "poly1305.c" +#include "prigen.c" +#include "rsa.c" +#include "sha256.c" \ No newline at end of file diff --git a/src/chacha20.c b/src/chacha20.c new file mode 100644 index 0000000..348ab9f --- /dev/null +++ b/src/chacha20.c @@ -0,0 +1,127 @@ +#ifndef __CHACHA20__ +#define __CHACHA20__ +#include +#include +#include "poly1305.c" + +static uint32_t chacha20_lr(uint32_t a, uint8_t b) +{ + return (a << b) | (a >> (32 - b)); +} + +static void chacha20_QR(uint32_t *cc, uint8_t a, uint8_t b, uint8_t c, uint8_t d) +{ + cc[a] += cc[b]; cc[d] ^= cc[a]; cc[d] = chacha20_lr(cc[d], 16); + cc[c] += cc[d]; cc[b] ^= cc[c]; cc[b] = chacha20_lr(cc[b], 12); + cc[a] += cc[b]; cc[d] ^= cc[a]; cc[d] = chacha20_lr(cc[d], 8); + cc[c] += cc[d]; cc[b] ^= cc[c]; cc[b] = chacha20_lr(cc[b], 7); +} + +static void chacha20_DR(uint32_t *cc) +{ + chacha20_QR(cc, 0, 4, 8, 12); + chacha20_QR(cc, 1, 5, 9, 13); + chacha20_QR(cc, 2, 6, 10, 14); + chacha20_QR(cc, 3, 7, 11, 15); + chacha20_QR(cc, 0, 5, 10, 15); + chacha20_QR(cc, 1, 6, 11, 12); + chacha20_QR(cc, 2, 7, 8, 13); + chacha20_QR(cc, 3, 4, 9, 14); +} + +static void chacha20_CB(uint32_t *cc) +{ + uint8_t i; + uint32_t x[16]; + for (i = 0; i < 16; i++) + { + x[i] = cc[i]; + } + for (i = 0; i < 10; i++) + { + chacha20_DR(cc); + } + for (i = 0; i < 16; i++) + { + cc[i] += x[i]; + } +} + +static void chacha20_S(uint32_t *cc, uint8_t *cs) +{ + for (uint8_t i = 0; i < 16; i++) + { + cs[4 * i] = (cc[i] & 0xFF); + cs[4 * i + 1] = ((cc[i] >> 8) & 0xFF); + cs[4 * i + 2] = ((cc[i] >> 16) & 0xFF); + cs[4 * i + 3] = ((cc[i] >> 24) & 0xFF); + } +} + +static void chacha20_block(uint8_t key[32], uint8_t nonce[12], uint32_t block, uint8_t out[64]) +{ + uint32_t cc[] = + { + 0x61707865, 0x3320646e, 0x79622d32, 0x6b206574, + + key[0] | (key[1] << 8) | (key[2] << 16) | (key[3] << 24), + key[4] | (key[5] << 8) | (key[6] << 16) | (key[7] << 24), + key[8] | (key[9] << 8) | (key[10] << 16) | (key[11] << 24), + key[12] | (key[13] << 8) | (key[14] << 16) | (key[15] << 24), + + key[16] | (key[17] << 8) | (key[18] << 16) | (key[19] << 24), + key[20] | (key[21] << 8) | (key[22] << 16) | (key[23] << 24), + key[24] | (key[25] << 8) | (key[26] << 16) | (key[27] << 24), + key[28] | (key[29] << 8) | (key[30] << 16) | (key[31] << 24), + + block, + + nonce[0] | (nonce[1] << 8) | (nonce[2] << 16) | (nonce[3] << 24), + nonce[4] | (nonce[5] << 8) | (nonce[6] << 16) | (nonce[7] << 24), + nonce[8] | (nonce[9] << 8) | (nonce[10] << 16) | (nonce[11] << 24) + }; + + chacha20_CB(cc); + chacha20_S(cc, out); +} + +/*Don't use block #0 if you are using this in conjunction with poly1305*/ +uint8_t* chacha20(uint8_t key[32], uint8_t nonce[12], uint32_t block, uint64_t count) +{ + if (count > (274877906944 - block * 64)) return NULL; + uint8_t* ret = malloc(0); + uint8_t ccblock[64]; + uint64_t size = 0; + while (count > 64) + { + ret = realloc(ret, size + 64); + chacha20_block(key, nonce, block++, ccblock); + for (uint8_t i = 0; i < 64; i++) ret[size + i] = ccblock[i]; + size += 64; + count -= 64; + } + if (count > 0) + { + ret = realloc(ret, size + count); + chacha20_block(key, nonce, block, ccblock); + for (uint8_t i = 0; i < count; i++) ret[size + i] = ccblock[i]; + } + return ret; +} + +//Calculates poly1305 for ciphertext encrypted with chacha20 +uint8_t* chacha20_poly1305(uint8_t key[32], uint8_t nonce[12], uint8_t* cipherText, uint64_t lengthInBytes) +{ + uint8_t* keydata = chacha20(key, nonce, 0, 32); + uint8_t r[16]; + uint8_t s[16]; + for (uint8_t i = 0; i < 16; i++) + { + r[i] = keydata[i]; + s[i] = keydata[i + 16]; + } + free(keydata); + return poly1305(r, s, cipherText, lengthInBytes); +} + +#endif \ No newline at end of file diff --git a/src/dhke.c b/src/dhke.c new file mode 100644 index 0000000..579ac4e --- /dev/null +++ b/src/dhke.c @@ -0,0 +1,351 @@ +#ifndef __DHKE__ +#define __DHKE__ +#include +#include +#include +#include +#include "sha256.c" + +/* +dhke(private, public) + +Here, "private" refers to random numbers intended to be used in the key exchange +while "public" refers to the public information shared in the communication. +If both are NULL, then it will generate random private numbers and return those +as a buffer. If you then pass those into the function again as the private +parameter and leave public as NULL, it will generate the public value meant to +be shared. If you pass in your private value as the private parameter and the +public value you acquired from the other person as the public parameter, it will +return the shared secret. + +dhke_prf(desiredBytes, secret, secretS, label, labelS, seed, seedS) + +Because the key is 4096 bits long which may either be too much or too little +depending on your purposes, this library also offers as a way to convert the +output of the key exchange into any arbitrary number of bytes appropriate +for your purposes. + +The "desired bytes" is the amount of bytes you want and the "secret" should +be the 4096 byte shared secret arrived at after the key exchange. Note that +the parameters that end with a capital S are just the length of bytes of +the buffer pointed to by the previous parameter. + +The label should specify the kind of operation being done. + +It is common to not use the Diffie-Hellman output directly but instead +transform it into another shared secret by first passing it into the PRF. +Since the PRF is effectively a pseudorandom number generator, if both sides +start with the same seed, they will still derive the same secret. In this +case, the label is specified as "master secret" without a null terminator. + +This master secret is then used to derive further session keys to be used +later in the communication, and at that point PRF() is called again with +a different level "key expansion" again without the null terminator. Using +different labels for different operations makes sure you get a different +set of pseudorandom numbers per operations which both parties should agree +upon. + +The seed helps increase the unpredictability of the PRF function by +introducing additional random numbers into the starting point of the PRF() +function. Since both parties need to produce the same numbers, this seed +will have to be shared publicly, typically as part of the same handshake +where they exchange their Diffie-Hellman numbers. + +The PRF() function utilizes the SHA-256 hash, but in theory could be +modified to support any hash. However, SHA-256 is a pretty common industry +standard, so for simplification reasons, the PRF() here does not require +a hash as an input but just chooses SHA-256 with appropriate parameters +automagically. +*/ + + +/* + key exchange here is fixed to using a group from RFC#3526 +*/ +static uint8_t RFC3526ID16[] = +{ + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34, + 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1, + 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, + 0x02, 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22, + 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD, + 0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, + 0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37, + 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45, + 0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, + 0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B, + 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED, + 0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, + 0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B, 0x1F, 0xE6, + 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D, + 0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, + 0x98, 0xDA, 0x48, 0x36, 0x1C, 0x55, 0xD3, 0x9A, + 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F, + 0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, + 0x1C, 0x62, 0xF3, 0x56, 0x20, 0x85, 0x52, 0xBB, + 0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D, + 0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, + 0xF1, 0x74, 0x6C, 0x08, 0xCA, 0x18, 0x21, 0x7C, + 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B, + 0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, + 0x9B, 0x27, 0x83, 0xA2, 0xEC, 0x07, 0xA2, 0x8F, + 0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9, + 0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18, + 0x39, 0x95, 0x49, 0x7C, 0xEA, 0x95, 0x6A, 0xE5, + 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10, + 0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAA, 0xC4, 0x2D, + 0xAD, 0x33, 0x17, 0x0D, 0x04, 0x50, 0x7A, 0x33, + 0xA8, 0x55, 0x21, 0xAB, 0xDF, 0x1C, 0xBA, 0x64, + 0xEC, 0xFB, 0x85, 0x04, 0x58, 0xDB, 0xEF, 0x0A, + 0x8A, 0xEA, 0x71, 0x57, 0x5D, 0x06, 0x0C, 0x7D, + 0xB3, 0x97, 0x0F, 0x85, 0xA6, 0xE1, 0xE4, 0xC7, + 0xAB, 0xF5, 0xAE, 0x8C, 0xDB, 0x09, 0x33, 0xD7, + 0x1E, 0x8C, 0x94, 0xE0, 0x4A, 0x25, 0x61, 0x9D, + 0xCE, 0xE3, 0xD2, 0x26, 0x1A, 0xD2, 0xEE, 0x6B, + 0xF1, 0x2F, 0xFA, 0x06, 0xD9, 0x8A, 0x08, 0x64, + 0xD8, 0x76, 0x02, 0x73, 0x3E, 0xC8, 0x6A, 0x64, + 0x52, 0x1F, 0x2B, 0x18, 0x17, 0x7B, 0x20, 0x0C, + 0xBB, 0xE1, 0x17, 0x57, 0x7A, 0x61, 0x5D, 0x6C, + 0x77, 0x09, 0x88, 0xC0, 0xBA, 0xD9, 0x46, 0xE2, + 0x08, 0xE2, 0x4F, 0xA0, 0x74, 0xE5, 0xAB, 0x31, + 0x43, 0xDB, 0x5B, 0xFC, 0xE0, 0xFD, 0x10, 0x8E, + 0x4B, 0x82, 0xD1, 0x20, 0xA9, 0x21, 0x08, 0x01, + 0x1A, 0x72, 0x3C, 0x12, 0xA7, 0x87, 0xE6, 0xD7, + 0x88, 0x71, 0x9A, 0x10, 0xBD, 0xBA, 0x5B, 0x26, + 0x99, 0xC3, 0x27, 0x18, 0x6A, 0xF4, 0xE2, 0x3C, + 0x1A, 0x94, 0x68, 0x34, 0xB6, 0x15, 0x0B, 0xDA, + 0x25, 0x83, 0xE9, 0xCA, 0x2A, 0xD4, 0x4C, 0xE8, + 0xDB, 0xBB, 0xC2, 0xDB, 0x04, 0xDE, 0x8E, 0xF9, + 0x2E, 0x8E, 0xFC, 0x14, 0x1F, 0xBE, 0xCA, 0xA6, + 0x28, 0x7C, 0x59, 0x47, 0x4E, 0x6B, 0xC0, 0x5D, + 0x99, 0xB2, 0x96, 0x4F, 0xA0, 0x90, 0xC3, 0xA2, + 0x23, 0x3B, 0xA1, 0x86, 0x51, 0x5B, 0xE7, 0xED, + 0x1F, 0x61, 0x29, 0x70, 0xCE, 0xE2, 0xD7, 0xAF, + 0xB8, 0x1B, 0xDD, 0x76, 0x21, 0x70, 0x48, 0x1C, + 0xD0, 0x06, 0x91, 0x27, 0xD5, 0xB0, 0x5A, 0xA9, + 0x93, 0xB4, 0xEA, 0x98, 0x8D, 0x8F, 0xDD, 0xC1, + 0x86, 0xFF, 0xB7, 0xDC, 0x90, 0xA6, 0xC0, 0x8F, + 0x4D, 0xF4, 0x35, 0xC9, 0x34, 0x06, 0x31, 0x99, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF +}; + +static void dhke_store(mpz_t n, uint8_t* b, uint32_t s) +{ + for (uint32_t i = 0; i < s; i++) + { + b[s - (i + 1)] = mpz_get_ui(n); + mpz_div_ui(n, n, 256); + } +} + +static void dhke_load(mpz_t n, uint8_t* b, uint32_t s) +{ + mpz_set_ui(n, 0); + for (uint32_t i = 0; i < s; i++) + { + mpz_mul_ui(n, n, 256); + mpz_add_ui(n, n, b[i]); + } +} + +/* + pass in NULL for both to get a new private value + pass in the private value with a null for public + to return the public value to be shared + pass in the private value and the public + received to compute the final key +*/ +uint8_t* dhke(uint8_t* private, uint8_t* public) +{ + mpz_t n, g, p; + mpz_init(n); + mpz_init(g); + mpz_init(p); + mpz_set_ui(g, 2); + dhke_load(p, RFC3526ID16, 512); + uint8_t* out = malloc(512); + + if (private == NULL && public == NULL) + { + FILE* f = fopen(DEVICE, "r"); + fread(out, 1, 512, f); + fclose(f); + out[0] = out[0] & 0b01111111; + } + else if (private != NULL && public == NULL) + { + dhke_load(n, private, 512); + mpz_powm(n, g, n, p); + dhke_store(n, out, 512); + } + else + { + mpz_t m; + mpz_init(m); + dhke_load(m, private, 512); + dhke_load(n, public, 512); + mpz_powm(n, n, m, p); + dhke_store(n, out, 512); + mpz_clear(m); + } + + mpz_clear(n); + mpz_clear(g); + mpz_clear(p); + return out; +} + +//HMAC(K, m) = H((K' xor opad) || H((K' xor ipad) || m)) +static uint8_t* dhke_hmac +( + uint8_t* (hash_func)(uint8_t*, uint32_t), + uint32_t Hs, //hash size + uint32_t Bs, //block size + uint8_t* K, + uint32_t Ks, //K size + uint8_t* M, + uint32_t Ms //M size +) +{ + uint8_t* tmp1; + uint8_t* Kp; //K prime + + if (Ks <= Bs) + { + Kp = malloc(Bs); + for (uint32_t i = 0; i < Bs; i++) + { + Kp[i] = i < Ks ? K[i] : 0; + } + } + else + { + tmp1 = hash_func(K, Ks); + Kp = malloc(Bs); + for (uint32_t i = 0; i < Bs; i++) + { + Kp[i] = i < Hs ? tmp1[i] : 0; + } + free(tmp1); + } + + //opad and ipad + uint8_t opad[Bs]; + uint8_t ipad[Bs]; + for (uint32_t i = 0; i < Bs; i++) + { + opad[i] = 0x5C; + ipad[i] = 0x36; + } + tmp1 = malloc(Bs + Ms); + for (uint32_t i = 0; i < Bs + Ms; i++) + { + tmp1[i] = i < Bs ? Kp[i] ^ ipad[i] : M[i - Bs]; + } + uint8_t* tmp2 = hash_func(tmp1, Bs + Ms); + free(tmp1); + + tmp1 = malloc(Bs + Hs); + for (uint32_t i = 0; i < Bs + Hs; i++) + { + tmp1[i] = i < Bs ? Kp[i] ^ opad[i] : tmp2[i - Bs]; + } + free(tmp2); + free(Kp); + + tmp2 = hash_func(tmp1, Bs + Hs); + free(tmp1); + return tmp2; + +} + +//A(0) = seed +//A(i) = HMAC_hash(secret, A(i-1)) +static uint8_t* dhke_hmac_A +( + uint8_t iter, //iteration + uint8_t* (hash_func)(uint8_t*, uint32_t), + uint32_t Hs, //hash size + uint32_t Bs, //block size + uint8_t* secret, + uint32_t secretS, //secret size + uint8_t* seed, + uint32_t seedS, //seed size + uint32_t* returnSize +) +{ + uint8_t* out; + if (iter == 0) + { + out = malloc(seedS); + for (uint32_t i = 0; i < seedS; i++) + { + out[i] = seed[i]; + } + *returnSize = seedS; + return out; + } + uint32_t retSize; + uint8_t* tmp = dhke_hmac_A(iter - 1, hash_func, Hs, Bs, secret, secretS, seed, seedS, &retSize); + out = dhke_hmac(hash_func, Hs, Bs, secret, secretS, tmp, retSize); + free(tmp); + *returnSize = Hs; + return out; +} + +//PRF(secret, label, seed) = P_(secret, label + seed) +// = HMAC_hash(secret, A(i) + seed) +//We are using sha256, but this is coded in such a way +// that we could extend it to other algorithms in the +// future. +uint8_t* dhke_prf +( + uint32_t desiredBytes, + uint8_t* secret, + uint32_t secretS, + uint8_t* label, + uint32_t labelS, + uint8_t* seed, + uint32_t seedS +) +{ + uint32_t Hs = 32; + uint32_t Bs = 64; + uint32_t iter = 1; + uint8_t* keystream = malloc(0); + uint8_t* labelSeed = malloc(labelS + seedS); + + for (uint32_t i = 0; i < labelS + seedS; i++) + labelSeed[i] = i < labelS ? label[i] : seed[i - labelS]; + + while (desiredBytes != 0) + { + uint32_t tmp1S; + uint8_t* tmp1 = dhke_hmac_A(iter, sha256, Hs, Bs, secret, secretS, labelSeed, labelS + seedS, &tmp1S); + tmp1 = realloc(tmp1, tmp1S + labelS + seedS); + for (uint32_t i = 0; i < labelS + seedS; i++) + tmp1[i + tmp1S] = labelSeed[i]; + uint8_t* tmp2 = dhke_hmac(sha256, Hs, Bs, secret, secretS, tmp1, tmp1S + labelS + seedS); + free(tmp1); + if (desiredBytes >= Bs) + { + keystream = realloc(keystream, iter * Bs); + for (uint32_t i = 0; i < Bs; i++) + keystream[i + (iter - 1) * Bs] = tmp2[i]; + desiredBytes -= Bs; + } + else + { + keystream = realloc(keystream, (iter - 1) * Bs + desiredBytes); + for (uint32_t i = 0; i < desiredBytes; i++) + keystream[i + (iter - 1) * Bs] = tmp2[i]; + desiredBytes = 0; + } + free(tmp2); + iter++; + } + free(labelSeed); + return keystream; +} +#endif diff --git a/src/headers.h b/src/headers.h new file mode 100644 index 0000000..9575e5e --- /dev/null +++ b/src/headers.h @@ -0,0 +1,27 @@ +#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 +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); diff --git a/src/poly1305.c b/src/poly1305.c new file mode 100644 index 0000000..587ad06 --- /dev/null +++ b/src/poly1305.c @@ -0,0 +1,86 @@ +#ifndef __POLY1305__ +#define __POLY1305__ +#include +#include +#include +#include + +static void poly1305_clamp(uint8_t* r) +{ + r[3] &= 15; + r[7] &= 15; + r[11] &= 15; + r[15] &= 15; + r[4] &= 252; + r[8] &= 252; + r[12] &= 252; +} + +static void poly1305_b2n_le(mpz_t n, uint8_t *b, uint8_t s, uint8_t init) +{ + mpz_set_ui(n, init); + for (int8_t i = s - 1; i >= 0; i--) + { + mpz_mul_ui(n, n, 256); + mpz_add_ui(n, n, b[i]); + } +} + +static void poly1305_dump(char *p, mpz_t n) +{ + char *nh = mpz_get_str(NULL, 16, n); + printf("%s = %s\n", p, nh); + free(nh); +} + +//bS and bR are read little-endian and 16-bytes +//return value must be freed +uint8_t* poly1305(uint8_t* bR, uint8_t* bS, uint8_t* bM, uint64_t bMs) +{ + uint8_t bP[] = + { + 0xfb, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0x03 + }; + + poly1305_clamp(bR); + + mpz_t P, r, s, Acc, b; + mpz_init(P); + mpz_init(b); + mpz_init(r); + mpz_init(s); + mpz_init(Acc); + mpz_set_ui(Acc, 0); + poly1305_b2n_le(P, bP, 17, 0); + poly1305_b2n_le(s, bS, 16, 0); + poly1305_b2n_le(r, bR, 16, 0); + + for (uint64_t i = 0;; i++) + { + uint64_t bytesLeft = bMs - (i * 16); + poly1305_b2n_le(b, bM + i * 16, bytesLeft < 16 ? bytesLeft : 16, 1); + mpz_add(Acc, Acc, b); + mpz_mul(Acc, Acc, r); + mpz_mod(Acc, Acc, P); + if (bytesLeft < 16) break; + } + mpz_add(Acc, Acc, s); + + uint8_t *ret = malloc(16); + for (uint8_t i = 0; i < 16; i++) + { + ret[i] = mpz_get_ui(Acc); + mpz_div_ui(Acc, Acc, 256); + } + mpz_clear(P); + mpz_clear(b); + mpz_clear(r); + mpz_clear(s); + mpz_clear(Acc); + return ret; +} +#endif \ No newline at end of file diff --git a/src/prigen.c b/src/prigen.c new file mode 100644 index 0000000..2458f6d --- /dev/null +++ b/src/prigen.c @@ -0,0 +1,130 @@ +#ifndef __PRIGEN__ +#define __PRIGEN__ +#include +#include +#include +#include + +static void PRIGEN_GetRandom(mpz_t n, uint16_t bytes, FILE *f) +{ + mpz_set_ui(n, 0); + for (uint16_t i = 0; i < bytes; i++) + { + mpz_mul_2exp(n, n, 8); + uint8_t c = fgetc(f); + if (i == 0) c |= 0b10000000; + if (i == bytes - 1) c |= 1; + mpz_add_ui(n, n, c); + } +} + +static void PRIGEN_ComputeDS(mpz_t n, mpz_t d, uint16_t *s) +{ + mpz_t t; + mpz_init(t); + mpz_set(d, n); + mpz_sub_ui(d, d, 1); + *s = 0; + for (;;) + { + mpz_mod_ui(t, d, 2); + if (mpz_sgn(t) != 0) break; + mpz_div_ui(d, d, 2); + *s = (*s) + 1; + } + mpz_clear(t); +} + +static uint8_t PRIGEN_PrimeTestOnce(mpz_t n, mpz_t d, uint16_t s, uint16_t witness) +{ + mpz_t x, m, a, two; + uint8_t ret = 0; + mpz_init(x); + mpz_init(m); + mpz_init(a); + mpz_init(two); + mpz_set_ui(two, 2); + mpz_sub_ui(m, n, 1); + mpz_set_ui(a, witness); + + for (uint16_t i = 0; i < s; i++) + { + if (i == 0) + { + mpz_powm(x, a, d, n); + if (mpz_cmp_ui(x, 1) == 0 || mpz_cmp(x, m) == 0) + { + ret = 1; + break; + } + } + else + { + mpz_powm(x, x, two, n); + if (mpz_cmp(x, m) == 0) + { + ret = 1; + break; + } + if (mpz_cmp_ui(x, 1) == 0) + { + ret = 0; + break; + } + } + } + + mpz_clear(x); + mpz_clear(m); + mpz_clear(a); + mpz_clear(two); + return ret; +} + +static uint8_t PRIGEN_PrimeTest(mpz_t n) +{ + mpz_t d; + mpz_init(d); + uint16_t s = 0; + PRIGEN_ComputeDS(n, d, &s); + + for (uint8_t a = 2; a < 12; a++) + { + if (!PRIGEN_PrimeTestOnce(n, d, s, a)) + { + mpz_clear(d); + return 0; + } + } + + mpz_clear(d); + return 1; +} + +static void PRIGEN_GeneratePrime(mpz_t n, int bytes) +{ + FILE *f = fopen(DEVICE, "r"); + do + { + PRIGEN_GetRandom(n, bytes, f); + } while (!PRIGEN_PrimeTest(n)); + fclose(f); +} + +/* Generate prime of X bytes */ +uint8_t* prigen(uint16_t bytes) +{ + uint8_t* buffer = malloc(bytes); + FILE *f = fopen(DEVICE, "r"); + mpz_t n, t; + mpz_init(n); + do + { + PRIGEN_GetRandom(n, bytes, f); + } while (!PRIGEN_PrimeTest(n)); + mpz_export(buffer, NULL, 1, 1, 0, 0, n); + mpz_clear(n); + fclose(f); + return buffer; +} +#endif diff --git a/src/rsa.c b/src/rsa.c new file mode 100644 index 0000000..14bd93c --- /dev/null +++ b/src/rsa.c @@ -0,0 +1,424 @@ +#ifndef __RSA__ +#define __RSA__ +#include +#include +#include +#include +#include "sha256.c" +#include "prigen.c" +/*typedef struct +{ + mpz_t n, k; + uint16_t bitWidth; +} rsakey_t;*/ + + +static void rsa_store(mpz_t n, uint8_t* b, uint32_t s) +{ + for (uint32_t i = 0; i < s; i++) + { + b[s - (i + 1)] = mpz_get_ui(n); + mpz_div_ui(n, n, 256); + } +} + +static void rsa_load(mpz_t n, uint8_t* b, uint32_t s) +{ + mpz_set_ui(n, 0); + for (uint32_t i = 0; i < s; i++) + { + mpz_mul_ui(n, n, 256); + mpz_add_ui(n, n, b[i]); + } +} + +//Keys and their sizes in terms of BYTES +rsakey_t rsa_public(uint8_t* p, uint16_t pS, uint8_t* q, uint16_t qS, uint8_t* e, uint16_t eS) +{ + mpz_t np, nq, ne; + mpz_init(np); + mpz_init(nq); + mpz_init(ne); + mpz_set_ui(np, 0); + mpz_set_ui(nq, 0); + mpz_set_ui(ne, 0); + + rsa_load(np, p, pS); + rsa_load(nq, q, qS); + rsa_load(ne, q, qS); + + rsakey_t ret; + ret.bitWidth = (pS + qS) * 8; + mpz_init(ret.n); + mpz_init(ret.k); + mpz_mul(ret.n, np, nq); + mpz_set(ret.k, ne); + + mpz_clear(np); + mpz_clear(nq); + mpz_clear(ne); + return ret; +} + +rsakey_t rsa_private(uint8_t* p, uint16_t pS, uint8_t* q, uint16_t qS, uint8_t* e, uint16_t eS) +{ + mpz_t np, nq, ne; + mpz_init(np); + mpz_init(nq); + mpz_init(ne); + mpz_set_ui(np, 0); + mpz_set_ui(nq, 0); + mpz_set_ui(ne, 0); + + rsa_load(np, p, pS); + rsa_load(nq, q, qS); + rsa_load(ne, q, qS); + + rsakey_t ret; + ret.bitWidth = (pS + qS) * 8; + mpz_init(ret.n); + mpz_init(ret.k); + mpz_mul(ret.n, np, nq); + mpz_set(ret.k, ne); + + mpz_sub_ui(np, np, 1); + mpz_sub_ui(nq, nq, 1); + mpz_mul(np, np, nq); + mpz_invert(ret.k, ret.k, np); + + mpz_clear(np); + mpz_clear(nq); + mpz_clear(ne); + return ret; +} + +uint8_t* rsa_export(rsakey_t key, uint8_t whichone, uint16_t* newsize) +{ + uint8_t* ret = malloc(key.bitWidth / 8); + switch (whichone) + { + case 'd': + case 'D': + case 'e': + case 'E': + rsa_store(key.k, ret, key.bitWidth / 8); + *newsize = key.bitWidth / 8; + return ret; + case 'n': + case 'N': + rsa_store(key.n, ret, key.bitWidth / 8); + *newsize = key.bitWidth / 8; + return ret; + } + *newsize = 0; + free(ret); + return NULL; +} + +rsakey_t rsa_import(uint8_t* bufferK, uint16_t byteSizeK, uint8_t* bufferN, uint16_t byteSizeN) +{ + 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); + + rsa_load(ret.k, bufferK, byteSizeK); + rsa_load(ret.n, bufferN, byteSizeN); + + return ret; +} + +void rsa_free(rsakey_t key) +{ + key.bitWidth = -1; + mpz_clear(key.n); + mpz_clear(key.k); +} + +//convert to PKCS#1 v1.5 encryption block +// note this is considered insecure and OAEP should be used instead +// OAEP is handled by a separate library in this framework +static uint8_t* RSA_Pad(uint16_t size, uint8_t* buffer, uint16_t bufferSizeInBytes) +{ + size /= 8; + if (bufferSizeInBytes - 11 > size) + { + return NULL; + } + uint8_t* block = malloc(size); + uint16_t i = 0; + block[i++] = 0x00; + block[i++] = 0x02; + + uint16_t psLen = size - (3 + bufferSizeInBytes); + uint8_t* ps = malloc(psLen); + FILE* f = fopen(DEVICE, "r"); + fread(ps, 1, psLen, f); + + for (uint16_t j = 0; j < psLen; j++) + { + while (ps[j] == 0x00) + { + ps[j] = fgetc(f); + } + block[i++] = ps[j]; + } + free(ps); + + block[i++] = 0x00; + fclose(f); + + for (uint16_t j = 0; j < bufferSizeInBytes; j++) + { + block[i++] = buffer[j]; + } + return block; +} + +//Removes the PKCS#1 v1.5 padding scheme +static uint8_t* RSA_DePad(uint16_t size, uint8_t* block, uint16_t* bufferSizeInBytes) +{ + uint16_t i = 2; + if (block[0] != 0x00 || (block[1] != 0x01 && block[1] != 0x02)) + { + *bufferSizeInBytes = -1; + return NULL; + } + while (block[i++] != 0) + { + if (i == size / 8) + { + *bufferSizeInBytes = -1; + return NULL; + } + } + if (i < 11) + { + *bufferSizeInBytes = -1; + return NULL; + } + + *bufferSizeInBytes = (size / 8) - i; + uint8_t* buffer = malloc(*bufferSizeInBytes); + for (uint16_t j = 0; i < (size / 8); i++) + { + buffer[j++] = block[i]; + } + return buffer; +} + +//convert to PKCS#1 v1.5 signature block +// note this is NOT considered insecure but PSS is often used instead +// PSS is handled by a separate library in this framework +static uint8_t* RSA_PadSig(uint16_t size, uint8_t* buffer, uint16_t bufferSizeInBytes) +{ + size /= 8; + if (bufferSizeInBytes - 11 > size) + { + return NULL; + } + uint8_t* block = malloc(size); + uint16_t i = 0; + block[i++] = 0x00; + block[i++] = 0x01; + + uint16_t psLen = size - (3 + bufferSizeInBytes); + for (uint16_t j = 0; j < psLen; j++) + { + block[i++] = 0xFF; + } + + block[i++] = 0x00; + + for (uint16_t j = 0; j < bufferSizeInBytes; j++) + { + block[i++] = buffer[j]; + } + return block; +} + +static uint8_t* RSA_Apply(rsakey_t key, uint8_t* block) +{ + uint8_t* newblock = malloc(key.bitWidth / 8); + mpz_t n; + mpz_init(n); + mpz_set_ui(n, 0); + + rsa_load(n, block, key.bitWidth / 8); + mpz_powm(n, n, key.k, key.n); + rsa_store(n, newblock, key.bitWidth / 8); + + mpz_clear(n); + return newblock; +} + +static uint8_t* RSA_MGF1(uint8_t* (hashfunc)(uint8_t*, uint32_t), uint32_t hashsize, uint8_t* seed, uint32_t seedsize, uint32_t totalsize) +{ + uint8_t* premask = malloc(seedsize + sizeof(uint32_t)); + for (uint32_t i = 0; i < seedsize; i++) premask[i] = seed[i]; + + uint8_t* mask = malloc(0); + for (uint32_t counter = 0; counter * hashsize < totalsize; counter++) + { + premask[seedsize + 0] = counter >> 24; + premask[seedsize + 1] = counter >> 16; + premask[seedsize + 2] = counter >> 8; + premask[seedsize + 3] = counter; + + uint8_t* postmask = hashfunc(premask, seedsize + sizeof(uint32_t)); + mask = realloc(mask, (counter + 1) * hashsize); + for (uint32_t i = 0; i < hashsize; i++) + { + mask[counter * hashsize + i] = postmask[i]; + } + free(postmask); + } + free(premask); + return mask; +} + +/*this uses sha-256*/ +static uint8_t* RSA_PadOAEP(uint16_t size, uint8_t* buffer, uint16_t mLen) +{ + uint32_t kLen = size / 8; //length of RSA modulus + uint32_t hLen = 32; //length of hash output + 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) + { + return NULL; + } + + //Build Seed + uint8_t Seed[hLen]; + FILE* f = fopen(DEVICE, "r"); + fread(Seed, 1, hLen, f); + fclose(f); + + //Build DB + uint8_t* HashL = sha256(NULL, 0); + uint8_t DB[dbLen]; + uint32_t pos = 0; + for (uint32_t i = 0; i < hLen; i++) DB[pos++] = HashL[i]; + free(HashL); + for (uint32_t i = 0; i < psLen; i++) DB[pos++] = 0x00; + DB[pos++] = 0x01; + for (uint32_t i = 0; i < mLen; i++) DB[pos++] = buffer[i]; + + //Mask DB + uint8_t* DBMask = RSA_MGF1(sha256, hLen, Seed, hLen, dbLen); + for (uint32_t i = 0; i < dbLen; i++) DB[i] ^= DBMask[i]; + free(DBMask); + + //Mask Seed + uint8_t* SeedMask = RSA_MGF1(sha256, hLen, DB, dbLen, hLen); + for (uint32_t i = 0; i < hLen; i++) Seed[i] ^= SeedMask[i]; + free(SeedMask); + + //Finalize + uint8_t* out = malloc(1 + hLen + dbLen); + pos = 0; + out[pos++] = 0x00; + for (uint32_t i = 0; i < hLen; i++) out[pos++] = Seed[i]; + for (uint32_t i = 0; i < dbLen; i++) out[pos++] = DB[i]; + return out; +} + +//Removes the OAEP padding scheme +static uint8_t* RSA_DeOAEP(uint16_t size, uint8_t* block, uint16_t* bufferSizeInBytes) +{ + if (block[0] != 0x00) return NULL; + uint32_t kLen = size / 8; //length of RSA modulus + uint32_t hLen = 32; //length of hash output + uint32_t dbLen = kLen - hLen - 1; //datablock length + + //Grab the masks + uint8_t MaskedSeed[hLen]; + for (uint32_t i = 0; i < hLen; i++) MaskedSeed[i] = block[i + 1]; + uint8_t MaskedDB[dbLen]; + for (uint32_t i = 0; i < dbLen; i++) MaskedDB[i] = block[i + 1 + hLen]; + + //Recover the original Seed + uint8_t* Seed = RSA_MGF1(sha256, hLen, MaskedDB, dbLen, hLen); + for (uint32_t i = 0; i < hLen; i++) Seed[i] ^= MaskedSeed[i]; + + //Recover the original DB + uint8_t* SeedMask = RSA_MGF1(sha256, hLen, Seed, hLen, dbLen); + for (uint32_t i = 0; i < dbLen; i++) MaskedDB[i] ^= SeedMask[i]; + free(Seed); + free(SeedMask); + + //Verify the padding + uint32_t pos = hLen; + while (MaskedDB[pos] == 0) + if ((++pos) == dbLen - 1) return NULL; + if (MaskedDB[pos] != 0x01) return NULL; + pos++; + + //Extract the data + uint32_t outlen = dbLen - pos; + uint8_t* out = malloc(outlen); + for (uint32_t i = 0; i < outlen; i++) + { + out[i] = MaskedDB[pos++]; + } + + *bufferSizeInBytes = outlen; + return out; +} + +uint8_t* rsa_encrypt(rsakey_t key, uint8_t padding, uint8_t* buffer, uint16_t bufferSize) +{ + uint8_t* block; + uint8_t* eblock; + if (padding == RSA_ENCRYPTION) + { + block = RSA_Pad(key.bitWidth, buffer, bufferSize); + eblock = RSA_Apply(key, block); + free(block); + } + else if (padding == RSA_SIGNATURE) + { + block = RSA_PadSig(key.bitWidth, buffer, bufferSize); + eblock = RSA_Apply(key, block); + free(block); + } + else if (padding == RSA_OAEP) + { + block = RSA_PadOAEP(key.bitWidth, buffer, bufferSize); + eblock = RSA_Apply(key, block); + free(block); + } + else + { + eblock = RSA_Apply(key, buffer); + } + return eblock; +} + +uint8_t* rsa_decrypt(rsakey_t key, uint8_t padding, uint8_t* eblock, uint16_t* bufferSize) +{ + uint8_t* block; + uint8_t* buffer; + if (padding == RSA_ENCRYPTION || padding == RSA_SIGNATURE) + { + block = RSA_Apply(key, eblock); + buffer = RSA_DePad(key.bitWidth, block, bufferSize); + free(block); + } + else if (padding == RSA_OAEP) + { + block = RSA_Apply(key, eblock); + buffer = RSA_DeOAEP(key.bitWidth, block, bufferSize); + free(block); + } + else + { + buffer = RSA_Apply(key, eblock); + } + return buffer; +} +#endif diff --git a/src/sha256.c b/src/sha256.c new file mode 100644 index 0000000..c81b7e6 --- /dev/null +++ b/src/sha256.c @@ -0,0 +1,184 @@ +#ifndef __SHA256__ +#define __SHA256__ +#include +#include +#include + +static uint32_t sha256_rr(uint32_t a, uint32_t b) +{ + return (a >> b) | (a << (32 - b)); +} + +static uint32_t sha256_init[] = +{ + 0x6a09e667, + 0xbb67ae85, + 0x3c6ef372, + 0xa54ff53a, + 0x510e527f, + 0x9b05688c, + 0x1f83d9ab, + 0x5be0cd19 +}; + +static uint32_t sha256_h[] = +{ + 0x6a09e667, + 0xbb67ae85, + 0x3c6ef372, + 0xa54ff53a, + 0x510e527f, + 0x9b05688c, + 0x1f83d9ab, + 0x5be0cd19 +}; + +static uint32_t sha256_k[] = +{ + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 +}; + +static void sha256_process_block(uint32_t *p) +{ + + uint8_t i; + uint32_t w[64]; + for (i = 0; i < 64; i++) w[i] = 0; + for (i = 0; i < 16; i++) w[i] = p[i]; + + uint32_t A, B, C, D, E, F, G, H; + uint32_t s0, s1, t1, t2, ch, maj; + for (i = 16; i < 64; i++) + { + s0 = sha256_rr(w[i - 15], 7) ^ sha256_rr(w[i - 15], 18) ^ (w[i - 15] >> 3); + s1 = sha256_rr(w[i - 2], 17) ^ sha256_rr(w[i - 2], 19) ^ (w[i - 2] >> 10); + w[i] = w[i - 16] + s0 + w[i - 7] + s1; + } + + i = 0; + + A = sha256_h[0]; + B = sha256_h[1]; + C = sha256_h[2]; + D = sha256_h[3]; + E = sha256_h[4]; + F = sha256_h[5]; + G = sha256_h[6]; + H = sha256_h[7]; + + for (i = 0; i < 64; i++) + { + s1 = sha256_rr(E, 6) ^ sha256_rr(E, 11) ^ sha256_rr(E, 25); + ch = (E & F) ^ ((~E) & G); + t1 = H + s1 + ch + sha256_k[i] + w[i]; + s0 = sha256_rr(A, 2) ^ sha256_rr(A, 13) ^ sha256_rr(A, 22); + maj = (A & B) ^ (A & C) ^ (B & C); + t2 = s0 + maj; + + H = G; + G = F; + F = E; + E = D + t1; + D = C; + C = B; + B = A; + A = t1 + t2; + } + + sha256_h[0] += A; + sha256_h[1] += B; + sha256_h[2] += C; + sha256_h[3] += D; + sha256_h[4] += E; + sha256_h[5] += F; + sha256_h[6] += G; + sha256_h[7] += H; + +} + +static uint32_t* sha256_pad(uint8_t* msg, uint32_t size, uint32_t* newsize) +{ + uint64_t osize = size * 8; + uint8_t *msg_padded = malloc(size); + for (uint64_t i = 0; i < size; i++) + { + msg_padded[i] = msg[i]; + } + if (size % 64 != 0 || size == 0) + { + msg_padded = realloc(msg_padded, size + 1); + msg_padded[size] = 0x80; + size++; + + while ((size + 8) % 64 != 0) + { + msg_padded = realloc(msg_padded, size + 1); + msg_padded[size] = 0; + size++; + } + + msg_padded = realloc(msg_padded, size + 8); + msg_padded[size + 0] = (osize >> 56) & 0xFF; + msg_padded[size + 1] = (osize >> 48) & 0xFF; + msg_padded[size + 2] = (osize >> 40) & 0xFF; + msg_padded[size + 3] = (osize >> 32) & 0xFF; + msg_padded[size + 4] = (osize >> 24) & 0xFF; + msg_padded[size + 5] = (osize >> 16) & 0xFF; + msg_padded[size + 6] = (osize >> 8) & 0xFF; + msg_padded[size + 7] = (osize >> 0) & 0xFF; + size += 8; + } + + uint32_t* output = malloc((size / 4) * sizeof(uint32_t)); + for (uint64_t i = 0; i < size / 4; i++) + { + output[i] = msg_padded[i * 4] << 24; + output[i] |= msg_padded[i * 4 + 1] << 16; + output[i] |= msg_padded[i * 4 + 2] << 8; + output[i] |= msg_padded[i * 4 + 3]; + } + free(msg_padded); + *newsize = size / 4; + return output; +} + +uint8_t* sha256(uint8_t* msg, uint32_t size) +{ + //set initial state + for (uint8_t i = 0; i < sizeof(sha256_h) / sizeof(uint32_t); i++) + { + sha256_h[i] = sha256_init[i]; + } + + //pad the message + uint32_t newsize; + uint32_t* padded = sha256_pad(msg, size, &newsize); + + //run the algorithm + for (uint32_t i = 0; i < newsize / 16; i++) + { + sha256_process_block(padded + (i * 16)); + } + + //done + free(padded); + + //breakout + uint8_t* out = malloc(sizeof(sha256_h) * sizeof(uint32_t)); + for (uint32_t i = 0; i < sizeof(sha256_h); i++) + { + out[i * sizeof(uint32_t) + 0] = sha256_h[i] >> 24; + out[i * sizeof(uint32_t) + 1] = sha256_h[i] >> 16; + out[i * sizeof(uint32_t) + 2] = sha256_h[i] >> 8; + out[i * sizeof(uint32_t) + 3] = sha256_h[i]; + } + return out; +} +#endif diff --git a/tests/SHA256.pdf b/tests/SHA256.pdf new file mode 100644 index 0000000000000000000000000000000000000000..bb176b5c08d1cdd21f50cb2496ad41476d5eb115 GIT binary patch literal 99090 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�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 literal 0 HcmV?d00001 -- 2.39.5