util.h

Go to the documentation of this file.

/*
   Copyright 2020 Raphael Beck
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
 
#ifndef CECIES_UTIL_H
#define CECIES_UTIL_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <time.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
 
#include "types.h"
#include "constants.h"
 
#define CECIES_MIN(x, y) (((x) < (y)) ? (x) : (y))
 
#define CECIES_MAX(x, y) (((x) > (y)) ? (x) : (y))
 
static inline size_t cecies_calc_aes_cbc_ciphertext_length(const size_t plaintext_length)
{
    return plaintext_length + 16 - (plaintext_length % 16);
}
 
static inline size_t cecies_calc_compression_bound(const size_t data_length)
{
    return data_length + (data_length >> 12) + (data_length >> 14) + (data_length >> 25) + 13;
}
 
static inline size_t cecies_calc_output_buffer_needed_size(const size_t input_buffer_length, const size_t key_size)
{
    //     1    2    3          4    5
    return 16 + 32 + key_size + 16 + input_buffer_length;
 
    // 1:  IV (AES initialization vector)
    // 2:  Salt (for HKDF)
    // 3:  R (ephemeral public key)
    // 4:  Tag (from AES-GCM)
    // 5:  Actual data array length
}
 
static inline size_t cecies_curve25519_calc_output_buffer_needed_size(const size_t input_buffer_length)
{
    return cecies_calc_output_buffer_needed_size(input_buffer_length, CECIES_X25519_KEY_SIZE);
}
 
static inline size_t cecies_curve448_calc_output_buffer_needed_size(const size_t input_buffer_length)
{
    return cecies_calc_output_buffer_needed_size(input_buffer_length, CECIES_X448_KEY_SIZE);
}
 
static inline size_t cecies_calc_base64_length(const size_t data_length)
{
    return ((4 * data_length / 3 + 3) & ~(unsigned)3) + 1;
}
 
CECIES_API int cecies_hexstr2bin(const char* hexstr, size_t hexstr_length, uint8_t* output, size_t output_size, size_t* output_length);
 
CECIES_API int cecies_bin2hexstr(const uint8_t* bin, size_t bin_length, char* output, size_t output_size, size_t* output_length, int uppercase);
 
CECIES_API char* cecies_get_version_str();
 
CECIES_API uint64_t cecies_get_version_nr();
 
CECIES_API int cecies_is_fprintf_enabled();
 
static inline int cecies_printvoid(FILE* stream, const char* format, ...)
{
    return 0;
}
 
CECIES_API extern int (*cecies_fprintf_fptr)(FILE* stream, const char* format, ...);
 
CECIES_API void cecies_enable_fprintf();
 
CECIES_API void cecies_disable_fprintf();
 
#define cecies_fprintf cecies_fprintf_fptr
 
static inline unsigned long long int cecies_get_random_big_integer()
{
    srand((unsigned int)time(NULL) * (unsigned int)time(NULL));
    return rand() * rand() * rand() * rand();
}
 
CECIES_API void cecies_dev_urandom(uint8_t* output_buffer, size_t output_buffer_size);
 
CECIES_API void cecies_free(void* mem);
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#endif // CECIES_UTIL_H