f_util.h

Go to the documentation of this file.

/*
    AUTHOR: Fábio Pereira da Silva
    YEAR: 2019-20
    LICENSE: MIT
    EMAIL: fabioegel@gmail.com or fabioegel@protonmail.com
*/

#include <stdint.h>
#include "mbedtls/sha256.h"
#include "mbedtls/aes.h"
#include "mbedtls/ecdsa.h"
#include "errors.h"

#ifdef __cplusplus
extern "C" {
#endif

#ifndef F_DOC_SKIP

 #define F_LOG_MAX 8*256
 #define LICENSE \
"MIT License\n\n\
Copyright (c) 2019 Fábio Pereira da Silva\n\n\
Permission is hereby granted, free of charge, to any person obtaining a copy\n\
of this software and associated documentation files (the \"Software\"), to deal\n\
in the Software without restriction, including without limitation the rights\n\
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n\
copies of the Software, and to permit persons to whom the Software is\n\
furnished to do so, subject to the following conditions:\n\n\
The above copyright notice and this permission notice shall be included in all\n\
copies or substantial portions of the Software.\n\n\
THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n\
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n\
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n\
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n\
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n\
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n\
SOFTWARE.\n\n\n"

#endif

#ifdef F_ESP32

 #define F_WDT_MAX_ENTROPY_TIME 2*120
 #define F_WDT_PANIC true
 #define F_WDT_MIN_TIME 20//4

#endif

int f_verify_system_entropy(uint32_t, void *, size_t, int);

int f_pass_must_have_at_least(char *, size_t, size_t, size_t, int);

#ifndef F_DOC_SKIP

int f_verify_system_entropy_begin();
void f_verify_system_entropy_finish();
int f_file_exists(char *);
int f_find_str(size_t *, char *, size_t, char *);
int f_find_replace(char *, size_t *, size_t, char *, size_t, char *, char *);
int f_is_integer(char *, size_t);
int is_filled_with_value(uint8_t *, size_t, uint8_t);

#endif

//#define F_ENTROPY_TYPE_PARANOIC (uint32_t)1476682819
#define F_ENTROPY_TYPE_PARANOIC (uint32_t)1477682819

//#define F_ENTROPY_TYPE_EXCELENT (uint32_t)1475885281
#define F_ENTROPY_TYPE_EXCELENT (uint32_t)1476885281

//#define F_ENTROPY_TYPE_GOOD (uint32_t)1471531015
#define F_ENTROPY_TYPE_GOOD (uint32_t)1472531015

//#define F_ENTROPY_TYPE_NOT_ENOUGH (uint32_t)1470001808
#define F_ENTROPY_TYPE_NOT_ENOUGH (uint32_t)1471001808

//#define F_ENTROPY_TYPE_NOT_RECOMENDED (uint32_t)1469703345
#define F_ENTROPY_TYPE_NOT_RECOMENDED (uint32_t)1470003345

#define ENTROPY_BEGIN f_verify_system_entropy_begin();

#define ENTROPY_END f_verify_system_entropy_finish();

#define F_PASS_MUST_HAVE_AT_LEAST_NONE (int)0

#define F_PASS_MUST_HAVE_AT_LEAST_ONE_NUMBER (int)1

#define F_PASS_MUST_HAVE_AT_LEAST_ONE_SYMBOL (int)2

#define F_PASS_MUST_HAVE_AT_LEAST_ONE_UPPER_CASE (int)4

#define F_PASS_MUST_HAVE_AT_LEAST_ONE_LOWER_CASE (int)8

#define F_PASS_IS_TOO_LONG (int)256

#define F_PASS_IS_TOO_SHORT (int)512

#define F_PASS_IS_OUT_OVF (int)1024//768

#ifndef F_DOC_SKIP

 #define F_PBKDF2_ITER_SZ 2*4096

typedef enum f_pbkdf2_err_t {
    F_PBKDF2_RESULT_OK=0,
    F_PBKDF2_ERR_CTX=95,
    F_PBKDF2_ERR_PKCS5,
    F_PBKDF2_ERR_INFO_SHA
} f_pbkdf2_err;

typedef enum f_aes_err {
    F_AES_RESULT_OK=0,
    F_AES_ERR_ENCKEY=30,
    F_AES_ERR_DECKEY,
    F_AES_ERR_MALLOC,
    F_AES_UNKNOW_DIRECTION,
    F_ERR_ENC_DECRYPT_FAILED
} f_aes_err;

typedef enum f_md_hmac_sha512_t {
   F_HMAC_SHA512_OK = 0,
   F_HMAC_SHA512_MALLOC = 304,
   F_HMAC_SHA512_ERR_INFO,
   F_HMAC_SHA512_ERR_SETUP,
   F_HMAC_SHA512_DIGEST_ERROR
} f_md_hmac_sha512;
typedef enum f_ecdsa_key_pair_err_t {
   F_ECDSA_KEY_PAIR_OK = 0,
   F_ECDSA_KEY_PAIR_NULL = 330,
   F_ECDSA_KEY_PAIR_MALLOC
} f_ecdsa_key_pair_err;

typedef struct f_ecdsa_key_pair_t {
    size_t public_key_sz;
    size_t private_key_sz;
    mbedtls_ecdsa_context *ctx;
    mbedtls_ecp_group_id gid;
    unsigned char public_key[MBEDTLS_ECDSA_MAX_LEN];
    unsigned char private_key[MBEDTLS_ECDSA_MAX_LEN];
} f_ecdsa_key_pair;

enum f_encode_decode_error_t {
   F_URL_ENCODE_OK = 0,
   F_ENCODE_BASE64_DEST_SMALL=11300,
   F_ENCODE_TO_BASE64_MALLOC,
   F_BASE64_DECODE_MALLOC,
   F_URL_ENCODE_EMPTY,
   F_URL_ENCODE_DEST_SMALL,
   F_BASE64_URL_DECODE_MALLOC,
   F_BASE64_URL_DECODE_MEMORY_SMALL,
   F_BASE64_URL_TO_BASE64_EMPTY_BASE64,
   F_BASE64_URL_TO_BASE64_MALLOC,
   F_URL_ENCODE_EMPTY_STRING,
   F_URL_ENCODE_WAITING_NEXT_NIBBLE,
   F_URL_INVALID_HEX_STRING,
   F_URL_NO_SPACE_IN_MEMORY_BUFFER,
   F_URL_ENCODE_INVALID_STRING
};

char *fhex2strv2(char *, const void *, size_t, int);
int f_sha256_digest(void **, int, uint8_t *, size_t);
f_pbkdf2_err f_pbkdf2_hmac(unsigned char *, size_t, unsigned char *, size_t, uint8_t *);
f_aes_err f_aes256cipher(uint8_t *, uint8_t *, void *, size_t, void *, int);

#endif

int f_passwd_comp_safe(char *, char *, size_t, size_t, size_t);

char *f_get_entropy_name(uint32_t);

uint32_t f_sel_to_entropy_level(int);

int f_str_to_hex(uint8_t *, char *);

#ifndef F_ESP32

typedef void (*rnd_fn)(void *, size_t);

void f_random_attach(rnd_fn);

void f_random(void *, size_t);

int get_console_passwd(char *, size_t);

#define F_GET_CH_MODE_NO_ECHO (int)(1<<16)

#define F_GET_CH_MODE_ANY_KEY (int)(1<<17)

int f_get_char_no_block(int);

#endif

int f_convert_to_long_int(unsigned long int *, char *, size_t);


int f_convert_to_unsigned_int(unsigned int *, char *, size_t);

int f_convert_to_long_int0x(unsigned long int *, char *, size_t);

int f_convert_to_long_int0(unsigned long int *, char *, size_t);

int f_convert_to_long_int_std(unsigned long int *, char *, size_t);

void *f_is_random_attached();

void f_random_detach();

int f_convert_to_unsigned_int0x(unsigned int *val, char *value, size_t value_sz);

int f_convert_to_unsigned_int0(unsigned int *val, char *value, size_t value_sz);

int f_convert_to_unsigned_int_std(unsigned int *val, char *value, size_t value_sz);

int f_convert_to_double(double *, const char *);

uint32_t crc32_init(unsigned char *, size_t, uint32_t);
//
typedef int (*fn_det)(void *, unsigned char *, size_t);

int f_reverse(unsigned char *, size_t);

f_md_hmac_sha512 f_hmac_sha512(unsigned char *, const unsigned char *, size_t, const unsigned char *, size_t);

typedef enum err_ecdsa_secret_key_valid_e {
   ERR_KEY_SK_SIZE_ZERO = 476,
   ERR_KEY_WRONG_SIZE,
   ERR_SK_MALLOC,
   ERR_SK_READ_BINARY,
   ERR_SK_CHECK
}  ERR_ECDSA_SECRET_KEY_VALID;

typedef enum err_ecdsa_public_key_valid_e {
   ERR_KEY_PK_SIZE_ZERO = 501,
   ERR_PK_MALLOC,
   ERR_PK_CHECK
}  ERR_ECDSA_PUBLIC_KEY_VALID;


ERR_ECDSA_SECRET_KEY_VALID
f_ecdsa_secret_key_valid(mbedtls_ecp_group_id, unsigned char *, size_t);

ERR_ECDSA_PUBLIC_KEY_VALID
f_ecdsa_public_key_valid(mbedtls_ecp_group_id, unsigned char *, size_t);

f_ecdsa_key_pair_err f_gen_ecdsa_key_pair(f_ecdsa_key_pair *, int, fn_det, void *);
int f_uncompress_elliptic_curve(uint8_t *, size_t, size_t *, mbedtls_ecp_group_id, uint8_t *, size_t);
uint8_t *f_ripemd160(const uint8_t *, size_t);
int f_url_encode(char *, size_t, size_t *, uint8_t *, size_t);
int f_encode_to_base64_dynamic(char **, size_t *, void *, size_t );
int f_base64_decode_dynamic(void **, size_t *, const char *, size_t);
int f_base64url_encode_dynamic(void **, size_t *, void *, size_t);
int f_encode_to_base64(char *, size_t, size_t *, void *, size_t);
int f_base64url_encode(char *, size_t, size_t *, void *, size_t);
int f_base64url_decode(void *, size_t, size_t *, const char *, size_t);
int f_url_base64_to_base64_dynamic(char **, size_t *, const char *, size_t);
int f_url_decode(void *, size_t, size_t *, const char *, size_t);

#define CLEAR_AND_FREE(ptr, size) free(memset(ptr, 0, size));
#ifdef __cplusplus
}
#endif