memutils.h

Go to the documentation of this file.

/* 2020-2026 Quantum Resistant Cryptographic Solutions Corporation
 * All Rights Reserved.
 *
 * NOTICE:
 * This software and all accompanying materials are the exclusive property of
 * Quantum Resistant Cryptographic Solutions Corporation (QRCS). The intellectual
 * and technical concepts contained herein are proprietary to QRCS and are
 * protected under applicable Canadian, U.S., and international copyright,
 * patent, and trade secret laws.
 *
 * CRYPTOGRAPHIC ALGORITHMS AND IMPLEMENTATIONS:
 * - This software includes implementations of cryptographic primitives and
 *   algorithms that are standardized or in the public domain, such as AES
 *   and SHA-3, which are not proprietary to QRCS.
 * - This software also includes cryptographic primitives, constructions, and
 *   algorithms designed by QRCS, including but not limited to RCS, SCB, CSX, QMAC, and
 *   related components, which are proprietary to QRCS.
 * - All source code, implementations, protocol compositions, optimizations,
 *   parameter selections, and engineering work contained in this software are
 *   original works of QRCS and are protected under this license.
 *
 * LICENSE AND USE RESTRICTIONS:
 * - This software is licensed under the Quantum Resistant Cryptographic Solutions
 *   Public Research and Evaluation License (QRCS-PREL), 2025-2026.
 * - Permission is granted solely for non-commercial evaluation, academic research,
 *   cryptographic analysis, interoperability testing, and feasibility assessment.
 * - Commercial use, production deployment, commercial redistribution, or
 *   integration into products or services is strictly prohibited without a
 *   separate written license agreement executed with QRCS.
 * - Licensing and authorized distribution are solely at the discretion of QRCS.
 *
 * EXPERIMENTAL CRYPTOGRAPHY NOTICE:
 * Portions of this software may include experimental, novel, or evolving
 * cryptographic designs. Use of this software is entirely at the user's risk.
 *
 * DISCLAIMER:
 * THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE, SECURITY, OR NON-INFRINGEMENT. QRCS DISCLAIMS ALL
 * LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING FROM THE USE OR MISUSE OF THIS SOFTWARE.
 *
 * FULL LICENSE:
 * This software is subject to the Quantum Resistant Cryptographic Solutions
 * Public Research and Evaluation License (QRCS-PREL), 2025-2026. The complete license terms
 * are provided in the accompanying LICENSE file or at https://www.qrcscorp.ca.
 *
 * Written by: John G. Underhill
 * Contact: contact@qrcscorp.ca
 */
 
#ifndef QSC_MEMUTILS_H
#define QSC_MEMUTILS_H
 
#include "qsccommon.h"
#include "intrinsics.h"
 
QSC_CPLUSPLUS_ENABLED_START


#if defined(QSC_SYSTEM_COMPILER_MSC)
    #include <intrin.h>
    #define QSC_MEMUTILS_MEMORY_FENCE() _ReadWriteBarrier()
#elif defined(QSC_SYSTEM_COMPILER_GCC)
    #define QSC_MEMUTILS_MEMORY_FENCE() __asm__ __volatile__ ("" ::: "memory")
#else
    #define QSC_MEMUTILS_MEMORY_FENCE()
#endif

#define QSC_MEMUTILS_CACHE_LINE_SIZE 64ULL

#define QSC_MEMUTILS_MEMORY_PAGE_SIZE 4096ULL

QSC_EXPORT_API void qsc_memutils_flush_cache_line(void *address);

QSC_EXPORT_API void qsc_memutils_prefetch_l1(uint8_t* address, size_t length);

QSC_EXPORT_API void qsc_memutils_prefetch_l2(uint8_t* address, size_t length);

QSC_EXPORT_API void qsc_memutils_prefetch_l3(uint8_t* address, size_t length);

QSC_EXPORT_API void* qsc_memutils_malloc(size_t length);

QSC_EXPORT_API size_t qsc_memutils_page_size(void);

QSC_EXPORT_API void* qsc_memutils_realloc(void* block, size_t length);

QSC_EXPORT_API void qsc_memutils_alloc_free(void* block);

QSC_EXPORT_API void* qsc_memutils_aligned_alloc(int32_t align, size_t length);

QSC_EXPORT_API void* qsc_memutils_aligned_realloc(void* block, size_t length);

QSC_EXPORT_API void qsc_memutils_aligned_free(void* block);

QSC_EXPORT_API void qsc_memutils_clear(void* output, size_t length);

QSC_EXPORT_API bool qsc_memutils_array_uniform(const uint8_t* input, size_t length);

QSC_EXPORT_API bool qsc_memutils_are_equal(const uint8_t* a, const uint8_t* b, size_t length);

QSC_EXPORT_API bool qsc_memutils_are_equal_128(const uint8_t* a, const uint8_t* b);

QSC_EXPORT_API bool qsc_memutils_are_equal_256(const uint8_t* a, const uint8_t* b);

QSC_EXPORT_API bool qsc_memutils_are_equal_512(const uint8_t* a, const uint8_t* b);

QSC_EXPORT_API void qsc_memutils_copy(void* output, const void* input, size_t length);

QSC_EXPORT_API void qsc_memutils_clmulepi64_si128(uint64_t r[2U], const uint64_t a[2U], const uint64_t b[2U], int32_t imm8);
 
#if defined(QSC_SYSTEM_HAS_AVX) && defined(QSC_SYSTEM_X86)
QSC_EXPORT_API void qsc_memutils_clmulepi64_si256_avx(__m128i r[4U], const __m128i a[2U], const __m128i b[2U]);
#endif

QSC_EXPORT_API void qsc_memutils_clmulepi64_si256(uint64_t r[8U], const uint64_t a[4U], const uint64_t b[4U]);

QSC_EXPORT_API bool qsc_memutils_greater_than_be128(const uint8_t* a, const uint8_t* b);

QSC_EXPORT_API bool qsc_memutils_greater_than_be256(const uint8_t* a, const uint8_t* b);

QSC_EXPORT_API bool qsc_memutils_greater_than_be512(const uint8_t* a, const uint8_t* b);

QSC_EXPORT_API bool qsc_memutils_greater_than_le128(const uint8_t* a, const uint8_t* b);

QSC_EXPORT_API bool qsc_memutils_greater_than_le256(const uint8_t* a, const uint8_t* b);

QSC_EXPORT_API bool qsc_memutils_greater_than_le512(const uint8_t* a, const uint8_t* b);

QSC_EXPORT_API void qsc_memutils_move(void* output, const void* input, size_t length);

QSC_EXPORT_API void qsc_memutils_secure_erase(void* block, size_t length);

QSC_EXPORT_API void qsc_memutils_secure_free(void* block, size_t length);

QSC_EXPORT_API void* qsc_memutils_secure_malloc(size_t length);

QSC_EXPORT_API void qsc_memutils_set_value(void* output, size_t length, uint8_t value);

QSC_EXPORT_API void qsc_memutils_xor(uint8_t* output, const uint8_t* input, size_t length);

QSC_EXPORT_API void qsc_memutils_xorv(uint8_t* output, const uint8_t value, size_t length);

QSC_EXPORT_API bool qsc_memutils_zeroed(const void* input, size_t length);
 
QSC_CPLUSPLUS_ENABLED_END
 
#endif