common.h

Go to the documentation of this file.

 
#ifndef OQS_COMMON_H
#define OQS_COMMON_H
 
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
 
#include <oqs/oqsconfig.h>
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#if defined(__GNUC__) || defined(__clang__)
#define IGNORE_UNUSED_FUNC __attribute__((unused))
#else
#define IGNORE_UNUSED_FUNC
#endif
 
#if defined(OQS_DISABLE_MEM_BLACK_BOX)
 
#warning "DANGER: OQS_DISABLE_MEM_BLACK_BOX is for internal testing only"
#warning "disabling optimization barrier may introduce side channels"
#define OQS_MEM_BLACK_BOX(v) (void)v
 
#elif defined(__GNUC__) || defined(__clang__)

#define OQS_MEM_BLACK_BOX(v)                                                   \
    do {                                                                       \
        __asm__ volatile("" : "+r"(v) :);                                      \
    } while (0)
 
#else
 
#pragma message("WARNING: non-GNUC/Clang toolchain detected. liboqs cannot     \
                 guarantee optimization barrier on unsupported platforms.      \
                 Compiler may introduce non-constant-time behaviors. Please    \
                 verify generated assembly and proceed with caution.")
#define OQS_MEM_BLACK_BOX(v) (void)v
#endif

#define OQS_EXIT_IF_NULLPTR(x, loc)                                            \
  do {                                                                         \
    if ((x) == (void *)0) {                                                    \
      fprintf(stderr, "Unexpected NULL returned from %s API. Exiting.\n",      \
              loc);                                                            \
      exit(EXIT_FAILURE);                                                      \
    }                                                                          \
  } while (0)

#ifdef OQS_USE_OPENSSL
#ifdef OPENSSL_NO_STDIO
#define OQS_OPENSSL_GUARD(x)                                                   \
  do {                                                                         \
    if (1 != (x)) {                                                            \
      fprintf(stderr, "Error return value from OpenSSL API: %d. Exiting.\n",   \
              x);                                                              \
      exit(EXIT_FAILURE);                                                      \
    }                                                                          \
  } while (0)
#else // OPENSSL_NO_STDIO
#define OQS_OPENSSL_GUARD(x)                                                   \
  do {                                                                         \
    if (1 != (x)) {                                                            \
      fprintf(stderr, "Error return value from OpenSSL API: %d. Exiting.\n",   \
              x);                                                              \
      OSSL_FUNC(ERR_print_errors_fp)(stderr);                                  \
      exit(EXIT_FAILURE);                                                      \
    }                                                                          \
  } while (0)
#endif // OPENSSL_NO_STDIO
#endif // OQS_USE_OPENSSL

#define SIZE_T_TO_INT_OR_EXIT(size_t_var_name, int_var_name)                   \
  int int_var_name = 0;                                                        \
  if (size_t_var_name <= INT_MAX) {                                            \
    int_var_name = (int)size_t_var_name;                                       \
  } else {                                                                     \
    exit(EXIT_FAILURE);                                                        \
  }

#if defined(_WIN32)
#define OQS_API __declspec(dllexport)
#else
#define OQS_API __attribute__((visibility("default")))
#endif
 
#if defined(OQS_SYS_UEFI)
#undef OQS_API
#define OQS_API
#endif

typedef enum {
    OQS_ERROR = -1,
    OQS_SUCCESS = 0,
    OQS_EXTERNAL_LIB_ERROR_OPENSSL = 50,
} OQS_STATUS;

typedef enum {
    OQS_CPU_EXT_INIT, /* Must be first */
    /* Start extension list */
    OQS_CPU_EXT_ADX,
    OQS_CPU_EXT_AES,
    OQS_CPU_EXT_AVX,
    OQS_CPU_EXT_AVX2,
    OQS_CPU_EXT_AVX512,
    OQS_CPU_EXT_BMI1,
    OQS_CPU_EXT_BMI2,
    OQS_CPU_EXT_PCLMULQDQ,
    OQS_CPU_EXT_VPCLMULQDQ,
    OQS_CPU_EXT_POPCNT,
    OQS_CPU_EXT_SSE,
    OQS_CPU_EXT_SSE2,
    OQS_CPU_EXT_SSE3,
    OQS_CPU_EXT_ARM_AES,
    OQS_CPU_EXT_ARM_SHA2,
    OQS_CPU_EXT_ARM_SHA3,
    OQS_CPU_EXT_ARM_NEON,
    /* End extension list */
    OQS_CPU_EXT_COUNT, /* Must be last */
} OQS_CPU_EXT;

OQS_API int OQS_CPU_has_extension(OQS_CPU_EXT ext);

OQS_API void OQS_init(void);

OQS_API void OQS_thread_stop(void);

OQS_API void OQS_destroy(void);

OQS_API const char *OQS_version(void);


OQS_API void *OQS_MEM_malloc(size_t size);

OQS_API void *OQS_MEM_calloc(size_t num_elements, size_t element_size);

OQS_API char *OQS_MEM_strdup(const char *str);

OQS_API int OQS_MEM_secure_bcmp(const void *a, const void *b, size_t len);

OQS_API void OQS_MEM_cleanse(void *ptr, size_t len);

OQS_API void OQS_MEM_secure_free(void *ptr, size_t len);

OQS_API void OQS_MEM_insecure_free(void *ptr);

void *OQS_MEM_aligned_alloc(size_t alignment, size_t size);

void OQS_MEM_aligned_free(void *ptr);

void OQS_MEM_aligned_secure_free(void *ptr, size_t len);
 
#if defined(__cplusplus)
} // extern "C"
#endif
 
#endif // OQS_COMMON_H