From a8a6efb2319f739e5faae550561dc27d9dd1e88d Mon Sep 17 00:00:00 2001 From: vnugent Date: Sun, 26 May 2024 17:39:40 -0400 Subject: chore: Update libs, reorder files, internalize private headers --- src/crypto/hkdf.c | 131 -------------------- src/crypto/impl/bcrypt.c | 263 --------------------------------------- src/crypto/impl/mbedtls.c | 174 -------------------------- src/crypto/impl/monocypher.c | 80 ------------ src/crypto/impl/openssl.c | 233 ----------------------------------- src/crypto/nc-crypto.c | 283 ------------------------------------------ src/hkdf.c | 131 ++++++++++++++++++++ src/hkdf.h | 61 ++++++++++ src/nc-crypto.c | 284 +++++++++++++++++++++++++++++++++++++++++++ src/nc-crypto.h | 59 +++++++++ src/nc-util.h | 95 +++++++++++++++ src/providers/bcrypt.c | 260 +++++++++++++++++++++++++++++++++++++++ src/providers/mbedtls.c | 174 ++++++++++++++++++++++++++ src/providers/monocypher.c | 78 ++++++++++++ src/providers/openssl.c | 233 +++++++++++++++++++++++++++++++++++ 15 files changed, 1375 insertions(+), 1164 deletions(-) delete mode 100644 src/crypto/hkdf.c delete mode 100644 src/crypto/impl/bcrypt.c delete mode 100644 src/crypto/impl/mbedtls.c delete mode 100644 src/crypto/impl/monocypher.c delete mode 100644 src/crypto/impl/openssl.c delete mode 100644 src/crypto/nc-crypto.c create mode 100644 src/hkdf.c create mode 100644 src/hkdf.h create mode 100644 src/nc-crypto.c create mode 100644 src/nc-crypto.h create mode 100644 src/nc-util.h create mode 100644 src/providers/bcrypt.c create mode 100644 src/providers/mbedtls.c create mode 100644 src/providers/monocypher.c create mode 100644 src/providers/openssl.c (limited to 'src') diff --git a/src/crypto/hkdf.c b/src/crypto/hkdf.c deleted file mode 100644 index 0d91d14..0000000 --- a/src/crypto/hkdf.c +++ /dev/null @@ -1,131 +0,0 @@ -/* -* Copyright (c) 2024 Vaughn Nugent -* -* Package: noscrypt -* File: hkdf.c -* -* This library is free software; you can redistribute it and/or -* modify it under the terms of the GNU Lesser General Public License -* as published by the Free Software Foundation; either version 2.1 -* of the License, or (at your option) any later version. -* -* This library is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -* Lesser General Public License for more details. -* -* You should have received a copy of the GNU Lesser General Public License -* along with noscrypt. If not, see http://www.gnu.org/licenses/. -*/ - - -#include "hkdf.h" - -/* Include string for memmove */ -#include - -#define HKDF_MIN(a, b) (a < b ? a : b) - -STATIC_ASSERT(HKDF_IN_BUF_SIZE > SHA256_DIGEST_SIZE, "HDK Buffer must be at least the size of the underlying hashing alg output") - -static _nc_fn_inline void ncWriteSpanS(span_t* span, uint32_t offset, const uint8_t* data, uint32_t size) -{ - DEBUG_ASSERT2(span != NULL, "Expected span to be non-null") - DEBUG_ASSERT2(data != NULL, "Expected data to be non-null") - DEBUG_ASSERT2(offset + size <= span->size, "Expected offset + size to be less than span size") - - /* Copy data to span */ - memmove(span->data + offset, data, size); -} - -static _nc_fn_inline void debugValidateHandler(const struct nc_hkdf_fn_cb_struct* handler) -{ - DEBUG_ASSERT(handler != NULL) - DEBUG_ASSERT(handler->update != NULL) - DEBUG_ASSERT(handler->finish != NULL) -} - -/* -* The following functions implements the HKDF expand function using an existing -* HMAC function. -* -* This follows the guidence from RFC 5869: https://tools.ietf.org/html/rfc5869 -*/ - -cstatus_t hkdfExpandProcess( - const struct nc_hkdf_fn_cb_struct* handler, - void* ctx, - const cspan_t* info, - span_t* okm -) -{ - cstatus_t result; - - uint8_t counter; - uint32_t tLen, okmOffset; - uint8_t t[HKDF_IN_BUF_SIZE]; - cspan_t tSpan, counterSpan; - - debugValidateHandler(handler); - - ncCryptoSecureZero(t, sizeof(t)); - - tLen = 0; /* T(0) is an empty string(zero length) */ - okmOffset = 0; - counter = 1; /* counter is offset by 1 for init */ - result = CSTATUS_FAIL; /* Start in fail state */ - - /* counter as a span */ - ncSpanInitC(&counterSpan, &counter, sizeof(counter)); - - /* Compute T(N) = HMAC(prk, T(n-1) | info | n) */ - while (okmOffset < okm->size) - { - ncSpanInitC(&tSpan, t, tLen); - - if (handler->update(ctx, &tSpan) != CSTATUS_OK) - { - goto Exit; - } - - if (handler->update(ctx, info) != CSTATUS_OK) - { - goto Exit; - } - - if (handler->update(ctx, &counterSpan) != CSTATUS_OK) - { - goto Exit; - } - - /* - * Write current hash state to t buffer. It is known - * that the t buffer must be at least the size of the - * underlying hash function output. - */ - if (handler->finish(ctx, t) != CSTATUS_OK) - { - goto Exit; - } - - /* tlen becomes the hash size or remaining okm size */ - tLen = HKDF_MIN(okm->size - okmOffset, SHA256_DIGEST_SIZE); - - DEBUG_ASSERT(tLen <= sizeof(t)); - - /* write the T buffer back to okm */ - ncWriteSpanS(okm, okmOffset, t, tLen); - - /* shift base okm pointer by T */ - okmOffset += tLen; - - /* increment counter */ - counter++; - } - - result = CSTATUS_OK; /* HMAC operation completed, so set success */ - -Exit: - - return result; -} diff --git a/src/crypto/impl/bcrypt.c b/src/crypto/impl/bcrypt.c deleted file mode 100644 index 9b01cac..0000000 --- a/src/crypto/impl/bcrypt.c +++ /dev/null @@ -1,263 +0,0 @@ -/* -* Copyright (c) 2024 Vaughn Nugent -* -* Package: noscrypt -* File: impl/bcrypt.c -* -* This library is free software; you can redistribute it and/or -* modify it under the terms of the GNU Lesser General Public License -* as published by the Free Software Foundation; either version 2.1 -* of the License, or (at your option) any later version. -* -* This library is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -* Lesser General Public License for more details. -* -* You should have received a copy of the GNU Lesser General Public License -* along with noscrypt. If not, see http://www.gnu.org/licenses/. -*/ - - -/* -* This file provides as many fallback implementations on Windows plaforms -* as possible using the bcrypt library. This file should be included behind -* other libarry implementations, as it is a fallback. -*/ - -#ifdef _NC_IS_WINDOWS - -#define WIN32_LEAN_AND_MEAN -#include -#include - -#include "nc-util.h" -#include "hkdf.h" - -#define IF_BC_FAIL(x) if(!BCRYPT_SUCCESS(x)) -#define BC_FAIL(x) if(!BCRYPT_SUCCESS(x)) return CSTATUS_FAIL; - -struct _bcrypt_ctx -{ - BCRYPT_ALG_HANDLE hAlg; - BCRYPT_HASH_HANDLE hHash; -}; - -_IMPLSTB NTSTATUS _bcInitSha256(struct _bcrypt_ctx* ctx, DWORD flags) -{ - NTSTATUS result; - - result = BCryptOpenAlgorithmProvider( - &ctx->hAlg, - BCRYPT_SHA256_ALGORITHM, - NULL, - flags - ); - - /* - * If operation failed, ensure the algorithm handle is null - * to make free code easier to cleanup - */ - if (!BCRYPT_SUCCESS(result)) - { - ctx->hAlg = NULL; - } - - return result; -} - -_IMPLSTB NTSTATUS _bcCreateHmac(struct _bcrypt_ctx* ctx, const cspan_t* key) -{ - /* - * NOTE: - * I am not explicitly managing the update object buffer. By setting - * the update object to NULL, and length to 0, the buffer will be - * managed by the bcrypt library. - * - * See: https://learn.microsoft.com/en-us/windows/win32/api/bcrypt/nf-bcrypt-bcryptcreatehash - */ - - return BCryptCreateHash( - ctx->hAlg, - &ctx->hHash, - NULL, - 0, - (uint8_t*)key->data, - key->size, - BCRYPT_HASH_REUSABLE_FLAG /* Enable reusable for expand function */ - ); -} - -_IMPLSTB NTSTATUS _bcCreate(struct _bcrypt_ctx* ctx) -{ - cspan_t key; - - /* Zero out key span for 0 size and NULL data ptr */ - SecureZeroMemory(&key, sizeof(cspan_t)); - - return _bcCreateHmac(ctx, &key); -} - -_IMPLSTB NTSTATUS _bcHashDataRaw(const struct _bcrypt_ctx* ctx, const uint8_t* data, uint32_t len) -{ - return BCryptHashData(ctx->hHash, (uint8_t*)data, len, 0); -} - -_IMPLSTB NTSTATUS _bcHashData(const struct _bcrypt_ctx* ctx, const cspan_t* data) -{ - return _bcHashDataRaw(ctx, data->data, data->size); -} - -_IMPLSTB NTSTATUS _bcFinishHash(const struct _bcrypt_ctx* ctx, sha256_t digestOut32) -{ - return BCryptFinishHash(ctx->hHash, digestOut32, sizeof(sha256_t), 0); -} - -_IMPLSTB void _bcDestroyCtx(struct _bcrypt_ctx* ctx) -{ - /* Free the update memory if it was allocated */ - if(ctx->hHash) BCryptDestroyHash(ctx->hHash); - - /* Close the algorithm provider */ - if (ctx->hAlg) BCryptCloseAlgorithmProvider(ctx->hAlg, 0); - - ctx->hAlg = NULL; - ctx->hHash = NULL; -} - -#ifndef _IMPL_SECURE_ZERO_MEMSET - /* - * On Windows, we can use SecureZeroMemory - * as platform zeroing function. - * - * NOTE: - * SecureZeroMemory2 uses volitle function argument - * pointers, which is a contested mehtod of compiler - * optimization prevention. GNU seems to oppose this method - * - * https://learn.microsoft.com/en-us/windows/win32/memory/winbase-securezeromemory2 - */ - #define _IMPL_SECURE_ZERO_MEMSET SecureZeroMemory -#endif /* !_IMPL_SECURE_ZERO_MEMSET */ - -/* -* Provide win32 fallback for sha256 digest if needed -*/ - -#ifndef _IMPL_CRYPTO_SHA256_DIGEST - - /* Export function fallack */ - #define _IMPL_CRYPTO_SHA256_DIGEST _bcrypt_sha256_digest - - _IMPLSTB cstatus_t _bcrypt_sha256_digest(const cspan_t* data, sha256_t digestOut32) - { - cstatus_t result; - struct _bcrypt_ctx ctx; - - result = CSTATUS_FAIL; /* Start in fail state */ - - IF_BC_FAIL(_bcInitSha256(&ctx, 0)) goto Exit; - - IF_BC_FAIL(_bcCreate(&ctx)) goto Exit; - - IF_BC_FAIL(_bcHashData(&ctx, data)) goto Exit; - - IF_BC_FAIL(_bcFinishHash(&ctx, digestOut32)) goto Exit; - - result = CSTATUS_OK; /* Hash operation completed, so set success */ - - Exit: - - _bcDestroyCtx(&ctx); - - return result; - } - -#endif /* !_IMPL_CRYPTO_SHA256_DIGEST */ - -#ifndef _IMPL_CRYPTO_SHA256_HMAC - - /* Export function */ - #define _IMPL_CRYPTO_SHA256_HMAC _bcrypt_hmac_sha256 - - _IMPLSTB cstatus_t _bcrypt_hmac_sha256(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32) - { - cstatus_t result; - struct _bcrypt_ctx ctx; - - result = CSTATUS_FAIL; /* Start in fail state */ - - /* Init context with hmac flag set */ - IF_BC_FAIL(_bcInitSha256(&ctx, BCRYPT_ALG_HANDLE_HMAC_FLAG)) goto Exit; - - IF_BC_FAIL(_bcCreateHmac(&ctx, key)) goto Exit; - - IF_BC_FAIL(_bcHashData(&ctx, data)) goto Exit; - - IF_BC_FAIL(_bcFinishHash(&ctx, hmacOut32)) goto Exit; - - result = CSTATUS_OK; /* HMAC operation completed, so set success */ - - Exit: - - _bcDestroyCtx(&ctx); - - return result; - } - -#endif /* !_IMPL_CRYPTO_SHA256_HMAC */ - -/* -* Provide a fallback HKDF expand function using the -* HMAC function as a base. -*/ - -#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND - - #define _IMPL_CRYPTO_SHA256_HKDF_EXPAND _bcrypt_fallback_hkdf_expand - - cstatus_t _bcrypt_hkdf_update(void* ctx, const cspan_t* data) - { - DEBUG_ASSERT(ctx != NULL) - - BC_FAIL(_bcHashData((struct _bcrypt_ctx*)ctx, data)) - return CSTATUS_OK; - } - - cstatus_t _bcrypt_hkdf_finish(void* ctx, sha256_t hmacOut32) - { - DEBUG_ASSERT(ctx != NULL) - - BC_FAIL(_bcFinishHash((struct _bcrypt_ctx*)ctx, hmacOut32)) - return CSTATUS_OK; - } - - _IMPLSTB cstatus_t _bcrypt_fallback_hkdf_expand(const cspan_t* prk, const cspan_t* info, span_t* okm) - { - cstatus_t result; - struct _bcrypt_ctx ctx; - struct nc_hkdf_fn_cb_struct handler; - - handler.update = _bcrypt_hkdf_update; - handler.finish = _bcrypt_hkdf_finish; - - /* Init bcrypt */ - BC_FAIL(_bcInitSha256(&ctx, BCRYPT_ALG_HANDLE_HMAC_FLAG)) - - BC_FAIL(_bcCreateHmac(&ctx, prk)) - - /* - * NOTE! Hmac reusable flag must be set to allow for multiple - * calls to the finish function without losing the context. - */ - - result = hkdfExpandProcess(&handler, &ctx, info, okm); - - _bcDestroyCtx(&ctx); - - return result; - } - -#endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXPAND */ - -#endif /* _NC_IS_WINDOWS */ \ No newline at end of file diff --git a/src/crypto/impl/mbedtls.c b/src/crypto/impl/mbedtls.c deleted file mode 100644 index df5201f..0000000 --- a/src/crypto/impl/mbedtls.c +++ /dev/null @@ -1,174 +0,0 @@ -/* -* Copyright (c) 2024 Vaughn Nugent -* -* Package: noscrypt -* File: mbedtls.c -* -* This library is free software; you can redistribute it and/or -* modify it under the terms of the GNU Lesser General Public License -* as published by the Free Software Foundation; either version 2.1 -* of the License, or (at your option) any later version. -* -* This library is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -* Lesser General Public License for more details. -* -* You should have received a copy of the GNU Lesser General Public License -* along with noscrypt. If not, see http://www.gnu.org/licenses/. -*/ - - -/* -* This file contains implemntation functions for the required -* cryptography primitives of noscrypt. This file stubs functionality -* using the Mbed-TLS library, if the builder desires to link against -* it. -*/ - -#ifdef MBEDTLS_CRYPTO_LIB - -/* Inline errors on linux in header files on linux */ -#ifndef inline - #define inline __inline - #include - #include - #include - #include - #include - #include - #undef inline -#else - #include - #include - #include - #include - #include - #include -#endif - -_IMPLSTB const mbedtls_md_info_t* _mbed_sha256_alg(void) -{ - const mbedtls_md_info_t* info; - /* Get sha256 md info for hdkf operations */ - info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); - DEBUG_ASSERT2(info != NULL, "Expected SHA256 md info pointer to be valid") - return info; -} - -#if SIZE_MAX < UINT64_MAX - #define _ssize_guard_int(x) if(x > SIZE_MAX) return 1; -#else - #define _ssize_guard_int(x) -#endif - -#ifndef _IMPL_CHACHA20_CRYPT - - /* Export chacha20 computation */ - #define _IMPL_CHACHA20_CRYPT _mbed_chacha20_encrypt - - _IMPLSTB cstatus_t _mbed_chacha20_encrypt( - const uint8_t* key, - const uint8_t* nonce, - const uint8_t* input, - uint8_t* output, - uint32_t dataLen - ) - { - _overflow_check(dataLen) - - /* Counter always starts at 0 */ - return mbedtls_chacha20_crypt( - key, - nonce, - 0x00u, /* nip-44 counter version */ - dataLen, - input, - output - ) == 0 ? CSTATUS_OK : CSTATUS_FAIL; - } - -#endif - -/* Export sha256 if not already defined */ -#ifndef _IMPL_CRYPTO_SHA256_DIGEST - - #define _IMPL_CRYPTO_SHA256_DIGEST _mbed_sha256_digest - - _IMPLSTB cstatus_t _mbed_sha256_digest(const cspan_t* data, sha256_t digestOut32) - { - _overflow_check(data->size) - - return mbedtls_sha256( - data->data, - data->size, - digestOut32, - 0 /* Set 0 for sha256 mode */ - ) == 0 ? CSTATUS_OK : CSTATUS_FAIL; - } - -#endif - -/* Export Sha256 hmac if not already defined by other libs */ -#ifndef _IMPL_CRYPTO_SHA256_HMAC - - #define _IMPL_CRYPTO_SHA256_HMAC _mbed_sha256_hmac - - _IMPLSTB cstatus_t _mbed_sha256_hmac(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32) - { - _overflow_check(data->size) - - /* Keys should never be large enough for this to matter, but sanity check. */ - DEBUG_ASSERT2(key->size < SIZE_MAX, "Expected key size to be less than SIZE_MAX") - - return mbedtls_md_hmac( - _mbed_sha256_alg(), - key->data, - key->size, - data->data, - data->size, - hmacOut32 - ) == 0 ? CSTATUS_OK : CSTATUS_FAIL; - } -#endif - -/* Export hkdf expand if not already defined */ -#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND - - #define _IMPL_CRYPTO_SHA256_HKDF_EXPAND _mbed_sha256_hkdf_expand - - _IMPLSTB cstatus_t _mbed_sha256_hkdf_expand(const cspan_t* prk, const cspan_t* info, span_t* okm) - { - /* These sizes should never be large enough to overflow on <64bit platforms, but sanity check */ - DEBUG_ASSERT(okm->size < SIZE_MAX) - DEBUG_ASSERT(prk->size < SIZE_MAX) - DEBUG_ASSERT(info->size < SIZE_MAX) - - return mbedtls_hkdf_expand( - _mbed_sha256_alg(), - prk->data, - prk->size, - info->data, - info->size, - okm->data, - okm->size - ) == 0 ? CSTATUS_OK : CSTATUS_FAIL; - } - -#endif - -/* Export fixed-time compare if not already defined */ -#ifndef _IMPL_CRYPTO_FIXED_TIME_COMPARE - - #define _IMPL_CRYPTO_FIXED_TIME_COMPARE _mbed_fixed_time_compare - - /* fixed-time memcmp */ - _IMPLSTB uint32_t _mbed_fixed_time_compare(const uint8_t* a, const uint8_t* b, uint32_t size) - { - _ssize_guard_int(size) - - return (uint32_t)mbedtls_ct_memcmp(a, b, size); - } -#endif - -#endif \ No newline at end of file diff --git a/src/crypto/impl/monocypher.c b/src/crypto/impl/monocypher.c deleted file mode 100644 index 7c9faea..0000000 --- a/src/crypto/impl/monocypher.c +++ /dev/null @@ -1,80 +0,0 @@ -/* -* Copyright (c) 2024 Vaughn Nugent -* -* Package: noscrypt -* File: impl/monocypher.c -* -* This library is free software; you can redistribute it and/or -* modify it under the terms of the GNU Lesser General Public License -* as published by the Free Software Foundation; either version 2.1 -* of the License, or (at your option) any later version. -* -* This library is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -* Lesser General Public License for more details. -* -* You should have received a copy of the GNU Lesser General Public License -* along with noscrypt. If not, see http://www.gnu.org/licenses/. -*/ - - -/* -* This file handles some fallbacks that may not be available on -* some platforms. More specifically: -* - Secure memset 0 -* - Chacha20 cipher -* -*/ - -#ifdef NC_ENABLE_MONOCYPHER - -#include - -#include "nc-util.h" - -/* Export secure memse0 */ -#ifndef _IMPL_SECURE_ZERO_MEMSET - - /* export cytpo wipe function as is */ - #define _IMPL_SECURE_ZERO_MEMSET crypto_wipe -#endif - -/* Export Chacha20 */ -#ifndef _IMPL_CHACHA20_CRYPT - - #define _IMPL_CHACHA20_CRYPT _mc_chacha20_crypt - - _IMPLSTB cstatus_t _mc_chacha20_crypt( - const uint8_t* key, - const uint8_t* nonce, - const uint8_t* input, - uint8_t* output, - uint32_t dataLen - ) - { - _overflow_check(dataLen) - - /* - * Function returns the next counter value which is not - * needed for noscrypt as encryptions are one-shot, and - * require a new nonce for each encryption. - * - * ITEF function uses a 12byte nonce which is required for - * nip-44 compliant encryption. - */ - crypto_chacha20_ietf( - output, - input, - (size_t)dataLen, - key, - nonce, - 0x00 /* Counter always starts at 0 */ - ); - - return CSTATUS_OK; - } - -#endif - -#endif /* !NC_ENABLE_MONOCYPHER */ \ No newline at end of file diff --git a/src/crypto/impl/openssl.c b/src/crypto/impl/openssl.c deleted file mode 100644 index 132c643..0000000 --- a/src/crypto/impl/openssl.c +++ /dev/null @@ -1,233 +0,0 @@ -/* -* Copyright (c) 2024 Vaughn Nugent -* -* Package: noscrypt -* File: impl/openssl.c -* -* This library is free software; you can redistribute it and/or -* modify it under the terms of the GNU Lesser General Public License -* as published by the Free Software Foundation; either version 2.1 -* of the License, or (at your option) any later version. -* -* This library is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -* Lesser General Public License for more details. -* -* You should have received a copy of the GNU Lesser General Public License -* along with noscrypt. If not, see http://www.gnu.org/licenses/. -*/ - - -/* Setup openssl */ -#ifdef OPENSSL_CRYPTO_LIB - -#include "nc-util.h" -#include - -#define _OSSL_FAIL(x) if(!(x)) return CSTATUS_FAIL; - -#ifndef _IMPL_SECURE_ZERO_MEMSET - - #define _IMPL_SECURE_ZERO_MEMSET _ossl_secure_zero_memset - - _IMPLSTB void _ossl_secure_zero_memset(void* ptr, size_t size) - { - _overflow_check(size) - - OPENSSL_cleanse(ptr, size); - } -#endif - -#ifndef _IMPL_CRYPTO_FIXED_TIME_COMPARE - - #define _IMPL_CRYPTO_FIXED_TIME_COMPARE _ossl_fixed_time_compare - - _IMPLSTB uint32_t _ossl_fixed_time_compare(const uint8_t* a, const uint8_t* b, uint32_t size) - { - int result; - - /* Size checks are required for platforms that have integer sizes under 32bit */ - _overflow_check(size) - - result = CRYPTO_memcmp(a, b, size); - - return (uint32_t)result; - } - -#endif /* _IMPL_CRYPTO_FIXED_TIME_COMPARE */ - - -#ifndef _IMPL_CRYPTO_SHA256_DIGEST - - #include - - #define _IMPL_CRYPTO_SHA256_DIGEST _ossl_sha256_digest - - _IMPLSTB cstatus_t _ossl_sha256_digest(const cspan_t* data, sha256_t digestOut32) - { - _overflow_check(data->size) - - _OSSL_FAIL(SHA256(data->data, data->size, digestOut32)) - - return CSTATUS_OK; - } - -#endif - -#ifndef _IMPL_CRYPTO_SHA256_HMAC - - #include - - /* Export function */ - #define _IMPL_CRYPTO_SHA256_HMAC _ossl_hmac_sha256 - - _IMPLSTB cstatus_t _ossl_hmac_sha256(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32) - { - unsigned int hmacLen; - - _overflow_check(key->size) - _overflow_check(data->size) - - hmacLen = sizeof(sha256_t); - - _OSSL_FAIL( - HMAC( - EVP_sha256(), - key->data, - key->size, - data->data, - data->size, - hmacOut32, - &hmacLen - ) - ) - - /* digest length should match the actual digest size */ - DEBUG_ASSERT(hmacLen == sizeof(sha256_t)) - - return CSTATUS_OK; - } - -#endif /* !_IMPL_CRYPTO_SHA256_HMAC */ - -#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND - - #include - #include "hkdf.h" - - #define _IMPL_CRYPTO_SHA256_HKDF_EXPAND _ossl_sha256_hkdf_expand - - cstatus_t _ossl_hkdf_update(void* ctx, const cspan_t* data) - { - DEBUG_ASSERT(ctx != NULL) - - _overflow_check(data->size) - - _OSSL_FAIL(EVP_DigestUpdate((EVP_MD_CTX*)ctx, data->data, data->size)) - - return CSTATUS_OK; - } - - cstatus_t _ossl_hkdf_finish(void* ctx, sha256_t hmacOut32) - { - unsigned int hmacSize; - - DEBUG_ASSERT(ctx != NULL) - - hmacSize = sizeof(sha256_t); - - _OSSL_FAIL(EVP_DigestFinal_ex((EVP_MD_CTX*)ctx, hmacOut32, &hmacSize)) - - /* When configured for sha256, should always be the same size in/out */ - DEBUG_ASSERT(hmacSize == sizeof(sha256_t)) - - return CSTATUS_OK; - } - - _IMPLSTB cstatus_t _ossl_sha256_hkdf_expand(const cspan_t* prk, const cspan_t* info, span_t* okm) - { - EVP_MD_CTX* ctx; - cstatus_t result; - struct nc_hkdf_fn_cb_struct handler; - - result = CSTATUS_FAIL; - - /* - * NOTE! Hmac reusable flag must be set to allow for multiple - * calls to the finish function without losing the context. - */ - - if ((ctx = EVP_MD_CTX_create()) == NULL) - { - return CSTATUS_FAIL; - } - - if (!EVP_DigestInit_ex2(ctx, EVP_sha256(), NULL)) - { - goto Cleanup; - } - - if (!EVP_DigestUpdate(ctx, prk->data, prk->size)) - { - goto Cleanup; - } - - handler.update = _ossl_hkdf_update; - handler.finish = _ossl_hkdf_finish; - - result = hkdfExpandProcess(&handler, ctx, info, okm); - - Cleanup: - - EVP_MD_CTX_destroy(ctx); - - return result; - } - -#endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXPAND */ - -#ifndef _IMPL_CHACHA20_CRYPT - - #define _IMPL_CHACHA20_CRYPT _ossl_chacha20_crypt - - _IMPLSTB cstatus_t _ossl_chacha20_crypt( - const uint8_t* key, - const uint8_t* nonce, - const uint8_t* input, - uint8_t* output, - uint32_t dataLen - ) - { - cstatus_t result; - EVP_CIPHER_CTX* ctx; - - result = CSTATUS_FAIL; - - if ((ctx = EVP_CIPHER_CTX_new()) == NULL) - { - return CSTATUS_FAIL; - } - - if (!EVP_EncryptInit_ex(ctx, EVP_chacha20(), NULL, key, nonce)) - { - goto Cleanup; - } - - if (!EVP_EncryptUpdate(ctx, output, (int*)&dataLen, input, dataLen)) - { - goto Cleanup; - } - - result = CSTATUS_OK; - - Cleanup: - - EVP_CIPHER_CTX_free(ctx); - - return result; - } - -#endif - -#endif /*!OPENSSL_CRYPTO_LIB */ \ No newline at end of file diff --git a/src/crypto/nc-crypto.c b/src/crypto/nc-crypto.c deleted file mode 100644 index 587d59d..0000000 --- a/src/crypto/nc-crypto.c +++ /dev/null @@ -1,283 +0,0 @@ -/* -* Copyright (c) 2024 Vaughn Nugent -* -* Package: noscrypt -* File: nc-crypto.c -* -* This library is free software; you can redistribute it and/or -* modify it under the terms of the GNU Lesser General Public License -* as published by the Free Software Foundation; either version 2.1 -* of the License, or (at your option) any later version. -* -* This library is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -* Lesser General Public License for more details. -* -* You should have received a copy of the GNU Lesser General Public License -* along with noscrypt. If not, see http://www.gnu.org/licenses/. -*/ - -#include "nc-util.h" -#include "nc-crypto.h" - -/* -* Functions are not forced inline, just suggested. -* So unless it becomes a performance issue, I will leave -* most/all impl functions inline and let the compiler -* decide. -*/ - -#define _IMPLSTB static _nc_fn_inline - -/* -* Impl .c files may define the following macros for function implementations: -* -* _IMPL_SECURE_ZERO_MEMSET secure memset 0 function -* _IMPL_CHACHA20_CRYPT chacha20 cipher function -* _IMPL_CRYPTO_FIXED_TIME_COMPARE fixed time compare function -* _IMPL_CRYPTO_SHA256_HMAC sha256 hmac function -* _IMPL_CRYPTO_SHA256_DIGEST standard sha256 digest function -* _IMPL_CRYPTO_SHA256_HKDF_EXPAND hkdf expand function -* _IMPL_CRYPTO_SHA256_HKDF_EXTRACT hkdf extract function -* -* Macros are used to allow the preprocessor to select the correct implementation -* or raise errors if no implementation is defined. -* -* Implementation functions can assume inputs have been checked/sanitized by the -* calling function, and should return CSTATUS_OK on success, CSTATUS_FAIL on failure. -*/ - - -/* -* Prioritize embedded builds with mbedtls -*/ -#include "impl/mbedtls.c" - -/* -* Include openssl as an alternative default -* implementation -*/ -#include "impl/openssl.c" - -/* -* Include win32 platform specific fallback support -* using bcrypt. -*/ -#include "impl/bcrypt.c" - -/* -* Handle default implementations of secure -* memset 0 functions for each platform. -*/ -#ifndef _IMPL_SECURE_ZERO_MEMSET - /* only incude bzero if libc version greater than 2.25 */ - #if defined(__GLIBC__) && defined(__GLIBC_MINOR__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 25 - /* - * When using libc, we can use explicit_bzero - * as secure memset implementation. - * - * https://sourceware.org/glibc/manual/2.39/html_mono/libc.html#Erasing-Sensitive-Data - */ - #include - extern void explicit_bzero(void* block, size_t len); - #define _IMPL_SECURE_ZERO_MEMSET explicit_bzero - #endif -#endif - -/* -* Finally fall back to monocipher to handle some -* that are not provided by other libraries. -* -* Platform specific opimizations are considered -* "better" than monocypher options, so this is -* added as a last resort. Momocypher is "correct" -* and portable, but not optimized for any specific -* platform. -*/ -#include "impl/monocypher.c" - - -#ifdef _IMPL_CRYPTO_SHA256_HMAC - - /* - * If a library does not provide a HKDF extract function, - * we can just use the HMAC function as a fallback. - * - * This is a fallback because another library may provide - * a more optimized implementation. - */ - - #ifndef _IMPL_CRYPTO_SHA256_HKDF_EXTRACT - - #define _IMPL_CRYPTO_SHA256_HKDF_EXTRACT _fallbackHkdfExtract - - _IMPLSTB cstatus_t _fallbackHkdfExtract(const cspan_t* salt, const cspan_t* ikm, sha256_t prk) - { - return _IMPL_CRYPTO_SHA256_HMAC(salt, ikm, prk); - } - - #endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXTRACT */ - -#endif /* _IMPL_CRYPTO_SHA256_HMAC */ - -/* Fallback for fixed time comparison for all platforms */ -#ifndef _IMPL_CRYPTO_FIXED_TIME_COMPARE - - #pragma message("Warning: No fixed time compare implementation defined, using fallback. This may not be secure on all platforms") - - #define _IMPL_CRYPTO_FIXED_TIME_COMPARE _fallbackFixedTimeCompare - - /* - * This implemntation is a slightly simplified version of - * MBed TLS constant time memcmp function, knowm to be a 32bit - * integer size - */ - - static uint32_t _fallbackFixedTimeCompare(const uint8_t* a, const uint8_t* b, uint32_t size) - { - size_t i; - uint32_t result; - uint8_t O; - volatile const uint8_t* A, * B; - - result = 0; - O = 0; - A = (volatile const uint8_t*)a; - B = (volatile const uint8_t*)b; - - /* Compare each byte */ - for(i = 0; i < size; i++) - { - /* Handle volatile read */ - O |= (A[i] ^ B[i]); - - result |= O; - } - - return result; - } - -#endif /* !_IMPL_CRYPTO_FIXED_TIME_COMPARE */ - - -/* -* Internal function implementations that perform -* basic checking and call the correct implementation -* for the desired crypto impl. -* -* The following functions MUST be assumed to -* perform basic input validation. Since these apis are -* internal, debug asserts are used to ensure the -* function has been used correctly. -*/ - -void ncCryptoSecureZero(void* ptr, uint32_t size) -{ - DEBUG_ASSERT2(ptr != NULL, "Expected ptr to be non-null") - -#ifndef _IMPL_SECURE_ZERO_MEMSET - #error "No secure memset implementation defined" -#endif /* _IMPL_SECURE_ZERO_MEMSET */ - - _IMPL_SECURE_ZERO_MEMSET(ptr, size); -} - -uint32_t ncCryptoFixedTimeComp(const uint8_t* a, const uint8_t* b, uint32_t size) -{ - DEBUG_ASSERT2(a != NULL, "Expected a to be non-null") - DEBUG_ASSERT2(b != NULL, "Expected b to be non-null") - -#ifndef _IMPL_CRYPTO_FIXED_TIME_COMPARE - #error "No fixed time compare implementation defined" -#endif /* !_IMPL_CRYPTO_FIXED_TIME_COMPARE */ - - return _IMPL_CRYPTO_FIXED_TIME_COMPARE(a, b, size); -} - -cstatus_t ncCryptoDigestSha256(const cspan_t* data, sha256_t digestOut32) -{ - /* Debug arg validate */ - DEBUG_ASSERT2(data != NULL && data->data != NULL, "Expected data to be non-null") - DEBUG_ASSERT2(digestOut32 != NULL, "Expected digestOut32 to be non-null") - -#ifndef _IMPL_CRYPTO_SHA256_DIGEST - #error "No SHA256 implementation defined" -#endif /* !_IMPL_CRYPTO_SHA256_DIGEST */ - - return _IMPL_CRYPTO_SHA256_DIGEST(data, digestOut32); -} - -cstatus_t ncCryptoHmacSha256(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32) -{ - /* Debug arg validate */ - DEBUG_ASSERT2(key != NULL && key->data != NULL, "Expected key to be non-null") - DEBUG_ASSERT2(data != NULL && data->data != NULL, "Expected data to be non-null") - DEBUG_ASSERT2(hmacOut32 != NULL && data->data != NULL, "Expected hmacOut32 to be non-null") - -#ifndef _IMPL_CRYPTO_SHA256_HMAC - #error "No SHA256 HMAC implementation defined" -#endif /* !_IMPL_CRYPTO_SHA256_HMAC */ - - return _IMPL_CRYPTO_SHA256_HMAC(key, data, hmacOut32); -} - -cstatus_t ncCryptoSha256HkdfExpand(const cspan_t* prk, const cspan_t* info, span_t* okm) -{ - /* Debug arg validate */ - DEBUG_ASSERT2(prk != NULL && prk->data != NULL, "Expected prk to be non-null") - DEBUG_ASSERT2(info != NULL && info->data != NULL, "Expected info to be non-null") - DEBUG_ASSERT2(okm != NULL && okm->data != NULL, "Expected okm to be non-null") - - /* - * RFC 5869: 2.3 - * "length of output keying material in octets (<= 255 * HashLen)" - * - * important as the counter is 1 byte, so it cannot overflow - */ - - if(okm->size > (uint32_t)(0xFFu * SHA256_DIGEST_SIZE)) - { - return CSTATUS_FAIL; - } - -#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND - #error "No SHA256 HKDF expand implementation defined" -#endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXPAND */ - - return _IMPL_CRYPTO_SHA256_HKDF_EXPAND(prk, info, okm); -} - -cstatus_t ncCryptoSha256HkdfExtract(const cspan_t* salt, const cspan_t* ikm, sha256_t prk) -{ - /* Debug arg validate */ - DEBUG_ASSERT2(salt != NULL, "Expected salt to be non-null") - DEBUG_ASSERT2(ikm != NULL, "Expected ikm to be non-null") - DEBUG_ASSERT2(prk != NULL, "Expected prk to be non-null") - -#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXTRACT - #error "No SHA256 HKDF extract implementation defined" -#endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXTRACT */ - - return _IMPL_CRYPTO_SHA256_HKDF_EXTRACT(salt, ikm, prk); -} - -cstatus_t ncCryptoChacha20( - const uint8_t key[CHACHA_KEY_SIZE], - const uint8_t nonce[CHACHA_NONCE_SIZE], - const uint8_t* input, - uint8_t* output, - uint32_t dataSize -) -{ - DEBUG_ASSERT2(key != NULL, "Expected key to be non-null") - DEBUG_ASSERT2(nonce != NULL, "Expected nonce to be non-null") - DEBUG_ASSERT2(input != NULL, "Expected input to be non-null") - DEBUG_ASSERT2(output != NULL, "Expected output to be non-null") - -#ifndef _IMPL_CHACHA20_CRYPT - #error "No chacha20 implementation defined" -#endif /* !_IMPL_CHACHA20_CRYPT */ - - return _IMPL_CHACHA20_CRYPT(key, nonce, input, output, dataSize); -} diff --git a/src/hkdf.c b/src/hkdf.c new file mode 100644 index 0000000..0d91d14 --- /dev/null +++ b/src/hkdf.c @@ -0,0 +1,131 @@ +/* +* Copyright (c) 2024 Vaughn Nugent +* +* Package: noscrypt +* File: hkdf.c +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public License +* as published by the Free Software Foundation; either version 2.1 +* of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with noscrypt. If not, see http://www.gnu.org/licenses/. +*/ + + +#include "hkdf.h" + +/* Include string for memmove */ +#include + +#define HKDF_MIN(a, b) (a < b ? a : b) + +STATIC_ASSERT(HKDF_IN_BUF_SIZE > SHA256_DIGEST_SIZE, "HDK Buffer must be at least the size of the underlying hashing alg output") + +static _nc_fn_inline void ncWriteSpanS(span_t* span, uint32_t offset, const uint8_t* data, uint32_t size) +{ + DEBUG_ASSERT2(span != NULL, "Expected span to be non-null") + DEBUG_ASSERT2(data != NULL, "Expected data to be non-null") + DEBUG_ASSERT2(offset + size <= span->size, "Expected offset + size to be less than span size") + + /* Copy data to span */ + memmove(span->data + offset, data, size); +} + +static _nc_fn_inline void debugValidateHandler(const struct nc_hkdf_fn_cb_struct* handler) +{ + DEBUG_ASSERT(handler != NULL) + DEBUG_ASSERT(handler->update != NULL) + DEBUG_ASSERT(handler->finish != NULL) +} + +/* +* The following functions implements the HKDF expand function using an existing +* HMAC function. +* +* This follows the guidence from RFC 5869: https://tools.ietf.org/html/rfc5869 +*/ + +cstatus_t hkdfExpandProcess( + const struct nc_hkdf_fn_cb_struct* handler, + void* ctx, + const cspan_t* info, + span_t* okm +) +{ + cstatus_t result; + + uint8_t counter; + uint32_t tLen, okmOffset; + uint8_t t[HKDF_IN_BUF_SIZE]; + cspan_t tSpan, counterSpan; + + debugValidateHandler(handler); + + ncCryptoSecureZero(t, sizeof(t)); + + tLen = 0; /* T(0) is an empty string(zero length) */ + okmOffset = 0; + counter = 1; /* counter is offset by 1 for init */ + result = CSTATUS_FAIL; /* Start in fail state */ + + /* counter as a span */ + ncSpanInitC(&counterSpan, &counter, sizeof(counter)); + + /* Compute T(N) = HMAC(prk, T(n-1) | info | n) */ + while (okmOffset < okm->size) + { + ncSpanInitC(&tSpan, t, tLen); + + if (handler->update(ctx, &tSpan) != CSTATUS_OK) + { + goto Exit; + } + + if (handler->update(ctx, info) != CSTATUS_OK) + { + goto Exit; + } + + if (handler->update(ctx, &counterSpan) != CSTATUS_OK) + { + goto Exit; + } + + /* + * Write current hash state to t buffer. It is known + * that the t buffer must be at least the size of the + * underlying hash function output. + */ + if (handler->finish(ctx, t) != CSTATUS_OK) + { + goto Exit; + } + + /* tlen becomes the hash size or remaining okm size */ + tLen = HKDF_MIN(okm->size - okmOffset, SHA256_DIGEST_SIZE); + + DEBUG_ASSERT(tLen <= sizeof(t)); + + /* write the T buffer back to okm */ + ncWriteSpanS(okm, okmOffset, t, tLen); + + /* shift base okm pointer by T */ + okmOffset += tLen; + + /* increment counter */ + counter++; + } + + result = CSTATUS_OK; /* HMAC operation completed, so set success */ + +Exit: + + return result; +} diff --git a/src/hkdf.h b/src/hkdf.h new file mode 100644 index 0000000..460e203 --- /dev/null +++ b/src/hkdf.h @@ -0,0 +1,61 @@ +/* +* Copyright (c) 2024 Vaughn Nugent +* +* Package: noscrypt +* File: hkdf.h +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public License +* as published by the Free Software Foundation; either version 2.1 +* of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with noscrypt. If not, see http://www.gnu.org/licenses/. +*/ + +#pragma once + +#ifndef _NC_HKDF_H +#define _NC_HKDF_H + +#include "nc-util.h" +#include "nc-crypto.h" + +/* +* IMPORTANT: +* The HKDF_IN_BUF_SIZE defintion sets the internal stack buffer size to use +* during fallback HKDF_Expand operations. +* +* 128 bytes should be more than enough for most use cases, without going +* overboard. Could be dialed in better for specific use cases later. +*/ + +#ifndef HKDF_IN_BUF_SIZE + #define HKDF_IN_BUF_SIZE 0x80 +#endif + + +/* typedefs for hdkf callback functions */ + +typedef cstatus_t (*hmac_hash_func)(void* ctx, const cspan_t* data); +typedef cstatus_t (*hmac_finish_fn)(void* ctx, sha256_t hmacOut32); + +struct nc_hkdf_fn_cb_struct +{ + hmac_hash_func update; + hmac_finish_fn finish; +}; + +cstatus_t hkdfExpandProcess( + const struct nc_hkdf_fn_cb_struct* handler, + void* ctx, + const cspan_t* info, + span_t* okm +); + +#endif /* !_NC_HKDF_H */ diff --git a/src/nc-crypto.c b/src/nc-crypto.c new file mode 100644 index 0000000..97b59cb --- /dev/null +++ b/src/nc-crypto.c @@ -0,0 +1,284 @@ +/* +* Copyright (c) 2024 Vaughn Nugent +* +* Package: noscrypt +* File: nc-crypto.c +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public License +* as published by the Free Software Foundation; either version 2.1 +* of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with noscrypt. If not, see http://www.gnu.org/licenses/. +*/ + +#include "nc-util.h" +#include "nc-crypto.h" +#include "hkdf.h" + +/* +* Functions are not forced inline, just suggested. +* So unless it becomes a performance issue, I will leave +* most/all impl functions inline and let the compiler +* decide. +*/ + +#define _IMPLSTB static _nc_fn_inline + +/* +* Impl .c files may define the following macros for function implementations: +* +* _IMPL_SECURE_ZERO_MEMSET secure memset 0 function +* _IMPL_CHACHA20_CRYPT chacha20 cipher function +* _IMPL_CRYPTO_FIXED_TIME_COMPARE fixed time compare function +* _IMPL_CRYPTO_SHA256_HMAC sha256 hmac function +* _IMPL_CRYPTO_SHA256_DIGEST standard sha256 digest function +* _IMPL_CRYPTO_SHA256_HKDF_EXPAND hkdf expand function +* _IMPL_CRYPTO_SHA256_HKDF_EXTRACT hkdf extract function +* +* Macros are used to allow the preprocessor to select the correct implementation +* or raise errors if no implementation is defined. +* +* Implementation functions can assume inputs have been checked/sanitized by the +* calling function, and should return CSTATUS_OK on success, CSTATUS_FAIL on failure. +*/ + + +/* +* Prioritize embedded builds with mbedtls +*/ +#include "providers/mbedtls.c" + +/* +* Include openssl as an alternative default +* implementation +*/ +#include "providers/openssl.c" + +/* +* Include win32 platform specific fallback support +* using bcrypt. +*/ +#include "providers/bcrypt.c" + +/* +* Handle default implementations of secure +* memset 0 functions for each platform. +*/ +#ifndef _IMPL_SECURE_ZERO_MEMSET + /* only incude bzero if libc version greater than 2.25 */ + #if defined(__GLIBC__) && defined(__GLIBC_MINOR__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 25 + /* + * When using libc, we can use explicit_bzero + * as secure memset implementation. + * + * https://sourceware.org/glibc/manual/2.39/html_mono/libc.html#Erasing-Sensitive-Data + */ + #include + extern void explicit_bzero(void* block, size_t len); + #define _IMPL_SECURE_ZERO_MEMSET explicit_bzero + #endif +#endif + +/* +* Finally fall back to monocipher to handle some +* that are not provided by other libraries. +* +* Platform specific opimizations are considered +* "better" than monocypher options, so this is +* added as a last resort. Momocypher is "correct" +* and portable, but not optimized for any specific +* platform. +*/ +#include "providers/monocypher.c" + + +#ifdef _IMPL_CRYPTO_SHA256_HMAC + + /* + * If a library does not provide a HKDF extract function, + * we can just use the HMAC function as a fallback. + * + * This is a fallback because another library may provide + * a more optimized implementation. + */ + + #ifndef _IMPL_CRYPTO_SHA256_HKDF_EXTRACT + + #define _IMPL_CRYPTO_SHA256_HKDF_EXTRACT _fallbackHkdfExtract + + _IMPLSTB cstatus_t _fallbackHkdfExtract(const cspan_t* salt, const cspan_t* ikm, sha256_t prk) + { + return _IMPL_CRYPTO_SHA256_HMAC(salt, ikm, prk); + } + + #endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXTRACT */ + +#endif /* _IMPL_CRYPTO_SHA256_HMAC */ + +/* Fallback for fixed time comparison for all platforms */ +#ifndef _IMPL_CRYPTO_FIXED_TIME_COMPARE + + #pragma message("Warning: No fixed time compare implementation defined, using fallback. This may not be secure on all platforms") + + #define _IMPL_CRYPTO_FIXED_TIME_COMPARE _fallbackFixedTimeCompare + + /* + * This implemntation is a slightly simplified version of + * MBed TLS constant time memcmp function, knowm to be a 32bit + * integer size + */ + + static uint32_t _fallbackFixedTimeCompare(const uint8_t* a, const uint8_t* b, uint32_t size) + { + size_t i; + uint32_t result; + uint8_t O; + volatile const uint8_t* A, * B; + + result = 0; + O = 0; + A = (volatile const uint8_t*)a; + B = (volatile const uint8_t*)b; + + /* Compare each byte */ + for(i = 0; i < size; i++) + { + /* Handle volatile read */ + O |= (A[i] ^ B[i]); + + result |= O; + } + + return result; + } + +#endif /* !_IMPL_CRYPTO_FIXED_TIME_COMPARE */ + + +/* +* Internal function implementations that perform +* basic checking and call the correct implementation +* for the desired crypto impl. +* +* The following functions MUST be assumed to +* perform basic input validation. Since these apis are +* internal, debug asserts are used to ensure the +* function has been used correctly. +*/ + +void ncCryptoSecureZero(void* ptr, uint32_t size) +{ + DEBUG_ASSERT2(ptr != NULL, "Expected ptr to be non-null") + +#ifndef _IMPL_SECURE_ZERO_MEMSET + #error "No secure memset implementation defined" +#endif /* _IMPL_SECURE_ZERO_MEMSET */ + + _IMPL_SECURE_ZERO_MEMSET(ptr, size); +} + +uint32_t ncCryptoFixedTimeComp(const uint8_t* a, const uint8_t* b, uint32_t size) +{ + DEBUG_ASSERT2(a != NULL, "Expected a to be non-null") + DEBUG_ASSERT2(b != NULL, "Expected b to be non-null") + +#ifndef _IMPL_CRYPTO_FIXED_TIME_COMPARE + #error "No fixed time compare implementation defined" +#endif /* !_IMPL_CRYPTO_FIXED_TIME_COMPARE */ + + return _IMPL_CRYPTO_FIXED_TIME_COMPARE(a, b, size); +} + +cstatus_t ncCryptoDigestSha256(const cspan_t* data, sha256_t digestOut32) +{ + /* Debug arg validate */ + DEBUG_ASSERT2(data != NULL && data->data != NULL, "Expected data to be non-null") + DEBUG_ASSERT2(digestOut32 != NULL, "Expected digestOut32 to be non-null") + +#ifndef _IMPL_CRYPTO_SHA256_DIGEST + #error "No SHA256 implementation defined" +#endif /* !_IMPL_CRYPTO_SHA256_DIGEST */ + + return _IMPL_CRYPTO_SHA256_DIGEST(data, digestOut32); +} + +cstatus_t ncCryptoHmacSha256(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32) +{ + /* Debug arg validate */ + DEBUG_ASSERT2(key != NULL && key->data != NULL, "Expected key to be non-null") + DEBUG_ASSERT2(data != NULL && data->data != NULL, "Expected data to be non-null") + DEBUG_ASSERT2(hmacOut32 != NULL && data->data != NULL, "Expected hmacOut32 to be non-null") + +#ifndef _IMPL_CRYPTO_SHA256_HMAC + #error "No SHA256 HMAC implementation defined" +#endif /* !_IMPL_CRYPTO_SHA256_HMAC */ + + return _IMPL_CRYPTO_SHA256_HMAC(key, data, hmacOut32); +} + +cstatus_t ncCryptoSha256HkdfExpand(const cspan_t* prk, const cspan_t* info, span_t* okm) +{ + /* Debug arg validate */ + DEBUG_ASSERT2(prk != NULL && prk->data != NULL, "Expected prk to be non-null") + DEBUG_ASSERT2(info != NULL && info->data != NULL, "Expected info to be non-null") + DEBUG_ASSERT2(okm != NULL && okm->data != NULL, "Expected okm to be non-null") + + /* + * RFC 5869: 2.3 + * "length of output keying material in octets (<= 255 * HashLen)" + * + * important as the counter is 1 byte, so it cannot overflow + */ + + if(okm->size > (uint32_t)(0xFFu * SHA256_DIGEST_SIZE)) + { + return CSTATUS_FAIL; + } + +#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND + #error "No SHA256 HKDF expand implementation defined" +#endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXPAND */ + + return _IMPL_CRYPTO_SHA256_HKDF_EXPAND(prk, info, okm); +} + +cstatus_t ncCryptoSha256HkdfExtract(const cspan_t* salt, const cspan_t* ikm, sha256_t prk) +{ + /* Debug arg validate */ + DEBUG_ASSERT2(salt != NULL, "Expected salt to be non-null") + DEBUG_ASSERT2(ikm != NULL, "Expected ikm to be non-null") + DEBUG_ASSERT2(prk != NULL, "Expected prk to be non-null") + +#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXTRACT + #error "No SHA256 HKDF extract implementation defined" +#endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXTRACT */ + + return _IMPL_CRYPTO_SHA256_HKDF_EXTRACT(salt, ikm, prk); +} + +cstatus_t ncCryptoChacha20( + const uint8_t key[CHACHA_KEY_SIZE], + const uint8_t nonce[CHACHA_NONCE_SIZE], + const uint8_t* input, + uint8_t* output, + uint32_t dataSize +) +{ + DEBUG_ASSERT2(key != NULL, "Expected key to be non-null") + DEBUG_ASSERT2(nonce != NULL, "Expected nonce to be non-null") + DEBUG_ASSERT2(input != NULL, "Expected input to be non-null") + DEBUG_ASSERT2(output != NULL, "Expected output to be non-null") + +#ifndef _IMPL_CHACHA20_CRYPT + #error "No chacha20 implementation defined" +#endif /* !_IMPL_CHACHA20_CRYPT */ + + return _IMPL_CHACHA20_CRYPT(key, nonce, input, output, dataSize); +} diff --git a/src/nc-crypto.h b/src/nc-crypto.h new file mode 100644 index 0000000..f04ebe0 --- /dev/null +++ b/src/nc-crypto.h @@ -0,0 +1,59 @@ + +/* +* Copyright (c) 2024 Vaughn Nugent +* +* Package: noscrypt +* File: nc-crypto.h +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public License +* as published by the Free Software Foundation; either version 2.1 +* of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with noscrypt. If not, see http://www.gnu.org/licenses/. +*/ + +#pragma once + +#ifndef _NC_CRYPTO_H +#define _NC_CRYPTO_H + +#include + +#define CHACHA_NONCE_SIZE 0x0cu /* Size of 12 is set by the cipher spec */ +#define CHACHA_KEY_SIZE 0x20u /* Size of 32 is set by the cipher spec */ +#define SHA256_DIGEST_SIZE 0x20u /* Size of 32 is set by the cipher spec */ + +typedef uint8_t cstatus_t; +#define CSTATUS_OK ((cstatus_t)0x01u) +#define CSTATUS_FAIL ((cstatus_t)0x00u) + +typedef uint8_t sha256_t[SHA256_DIGEST_SIZE]; + +uint32_t ncCryptoFixedTimeComp(const uint8_t* a, const uint8_t* b, uint32_t size); + +void ncCryptoSecureZero(void* ptr, uint32_t size); + +cstatus_t ncCryptoDigestSha256(const cspan_t* data, sha256_t digestOut32); + +cstatus_t ncCryptoHmacSha256(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32); + +cstatus_t ncCryptoSha256HkdfExpand(const cspan_t* prk, const cspan_t* info, span_t* okm); + +cstatus_t ncCryptoSha256HkdfExtract(const cspan_t* salt, const cspan_t* ikm, sha256_t prk); + +cstatus_t ncCryptoChacha20( + const uint8_t key[CHACHA_KEY_SIZE], + const uint8_t nonce[CHACHA_NONCE_SIZE], + const uint8_t* input, + uint8_t* output, + uint32_t dataSize +); + +#endif /* !_NC_CRYPTO_H */ diff --git a/src/nc-util.h b/src/nc-util.h new file mode 100644 index 0000000..8fb74ff --- /dev/null +++ b/src/nc-util.h @@ -0,0 +1,95 @@ + +/* +* Copyright (c) 2024 Vaughn Nugent +* +* Package: noscrypt +* File: nc-util.h +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public License +* as published by the Free Software Foundation; either version 2.1 +* of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with noscrypt. If not, see http://www.gnu.org/licenses/. +*/ + +#pragma once + +#ifndef _NC_UTIL_H +#define _NC_UTIL_H + +#include "platform.h" + +/* NULL */ +#ifndef NULL + #define NULL ((void*)0) +#endif /* !NULL */ + +#ifdef DEBUG + /* Must include assert.h for assertions */ + #include + #define DEBUG_ASSERT(x) assert(x); + #define DEBUG_ASSERT2(x, message) assert(x && message); + + /* + * Compiler enabled static assertion keywords are + * only available in C11 and later. Later versions + * have macros built-in from assert.h so we can use + * the static_assert macro directly. + * + * Static assertions are only used for testing such as + * sanity checks and this library targets the c89 standard + * so static_assret very likely will not be available. + */ + #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define STATIC_ASSERT(x, m) static_assert(x, m) + #elif !defined(STATIC_ASSERT) + #define STATIC_ASSERT(x, m) + #pragma message("Static assertions are not supported by this language version") + #endif + +#else + #define DEBUG_ASSERT(x) + #define DEBUG_ASSERT2(x, message) + #define STATIC_ASSERT(x, m) +#endif + +#include + +#if SIZE_MAX < UINT32_MAX + #define _overflow_check(x) if(x > SIZE_MAX) return CSTATUS_FAIL; +#else + #define _overflow_check(x) +#endif + +typedef struct memory_span_struct +{ + uint8_t* data; + uint32_t size; +} span_t; + +typedef struct read_only_memory_span_struct +{ + const uint8_t* data; + uint32_t size; +} cspan_t; + +static _nc_fn_inline void ncSpanInitC(cspan_t* span, const uint8_t* data, uint32_t size) +{ + span->data = data; + span->size = size; +} + +static _nc_fn_inline void ncSpanInit(span_t* span, uint8_t* data, uint32_t size) +{ + span->data = data; + span->size = size; +} + +#endif /* !_NC_UTIL_H */ \ No newline at end of file diff --git a/src/providers/bcrypt.c b/src/providers/bcrypt.c new file mode 100644 index 0000000..d1b9aa5 --- /dev/null +++ b/src/providers/bcrypt.c @@ -0,0 +1,260 @@ +/* +* Copyright (c) 2024 Vaughn Nugent +* +* Package: noscrypt +* File: impl/bcrypt.c +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public License +* as published by the Free Software Foundation; either version 2.1 +* of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with noscrypt. If not, see http://www.gnu.org/licenses/. +*/ + + +/* +* This file provides as many fallback implementations on Windows plaforms +* as possible using the bcrypt library. This file should be included behind +* other libarry implementations, as it is a fallback. +*/ + +#ifdef _NC_IS_WINDOWS + +#define WIN32_LEAN_AND_MEAN +#include +#include + +#define IF_BC_FAIL(x) if(!BCRYPT_SUCCESS(x)) +#define BC_FAIL(x) if(!BCRYPT_SUCCESS(x)) return CSTATUS_FAIL; + +struct _bcrypt_ctx +{ + BCRYPT_ALG_HANDLE hAlg; + BCRYPT_HASH_HANDLE hHash; +}; + +_IMPLSTB NTSTATUS _bcInitSha256(struct _bcrypt_ctx* ctx, DWORD flags) +{ + NTSTATUS result; + + result = BCryptOpenAlgorithmProvider( + &ctx->hAlg, + BCRYPT_SHA256_ALGORITHM, + NULL, + flags + ); + + /* + * If operation failed, ensure the algorithm handle is null + * to make free code easier to cleanup + */ + if (!BCRYPT_SUCCESS(result)) + { + ctx->hAlg = NULL; + } + + return result; +} + +_IMPLSTB NTSTATUS _bcCreateHmac(struct _bcrypt_ctx* ctx, const cspan_t* key) +{ + /* + * NOTE: + * I am not explicitly managing the update object buffer. By setting + * the update object to NULL, and length to 0, the buffer will be + * managed by the bcrypt library. + * + * See: https://learn.microsoft.com/en-us/windows/win32/api/bcrypt/nf-bcrypt-bcryptcreatehash + */ + + return BCryptCreateHash( + ctx->hAlg, + &ctx->hHash, + NULL, + 0, + (uint8_t*)key->data, + key->size, + BCRYPT_HASH_REUSABLE_FLAG /* Enable reusable for expand function */ + ); +} + +_IMPLSTB NTSTATUS _bcCreate(struct _bcrypt_ctx* ctx) +{ + cspan_t key; + + /* Zero out key span for 0 size and NULL data ptr */ + SecureZeroMemory(&key, sizeof(cspan_t)); + + return _bcCreateHmac(ctx, &key); +} + +_IMPLSTB NTSTATUS _bcHashDataRaw(const struct _bcrypt_ctx* ctx, const uint8_t* data, uint32_t len) +{ + return BCryptHashData(ctx->hHash, (uint8_t*)data, len, 0); +} + +_IMPLSTB NTSTATUS _bcHashData(const struct _bcrypt_ctx* ctx, const cspan_t* data) +{ + return _bcHashDataRaw(ctx, data->data, data->size); +} + +_IMPLSTB NTSTATUS _bcFinishHash(const struct _bcrypt_ctx* ctx, sha256_t digestOut32) +{ + return BCryptFinishHash(ctx->hHash, digestOut32, sizeof(sha256_t), 0); +} + +_IMPLSTB void _bcDestroyCtx(struct _bcrypt_ctx* ctx) +{ + /* Free the update memory if it was allocated */ + if(ctx->hHash) BCryptDestroyHash(ctx->hHash); + + /* Close the algorithm provider */ + if (ctx->hAlg) BCryptCloseAlgorithmProvider(ctx->hAlg, 0); + + ctx->hAlg = NULL; + ctx->hHash = NULL; +} + +#ifndef _IMPL_SECURE_ZERO_MEMSET + /* + * On Windows, we can use SecureZeroMemory + * as platform zeroing function. + * + * NOTE: + * SecureZeroMemory2 uses volitle function argument + * pointers, which is a contested mehtod of compiler + * optimization prevention. GNU seems to oppose this method + * + * https://learn.microsoft.com/en-us/windows/win32/memory/winbase-securezeromemory2 + */ + #define _IMPL_SECURE_ZERO_MEMSET SecureZeroMemory +#endif /* !_IMPL_SECURE_ZERO_MEMSET */ + +/* +* Provide win32 fallback for sha256 digest if needed +*/ + +#ifndef _IMPL_CRYPTO_SHA256_DIGEST + + /* Export function fallack */ + #define _IMPL_CRYPTO_SHA256_DIGEST _bcrypt_sha256_digest + + _IMPLSTB cstatus_t _bcrypt_sha256_digest(const cspan_t* data, sha256_t digestOut32) + { + cstatus_t result; + struct _bcrypt_ctx ctx; + + result = CSTATUS_FAIL; /* Start in fail state */ + + IF_BC_FAIL(_bcInitSha256(&ctx, 0)) goto Exit; + + IF_BC_FAIL(_bcCreate(&ctx)) goto Exit; + + IF_BC_FAIL(_bcHashData(&ctx, data)) goto Exit; + + IF_BC_FAIL(_bcFinishHash(&ctx, digestOut32)) goto Exit; + + result = CSTATUS_OK; /* Hash operation completed, so set success */ + + Exit: + + _bcDestroyCtx(&ctx); + + return result; + } + +#endif /* !_IMPL_CRYPTO_SHA256_DIGEST */ + +#ifndef _IMPL_CRYPTO_SHA256_HMAC + + /* Export function */ + #define _IMPL_CRYPTO_SHA256_HMAC _bcrypt_hmac_sha256 + + _IMPLSTB cstatus_t _bcrypt_hmac_sha256(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32) + { + cstatus_t result; + struct _bcrypt_ctx ctx; + + result = CSTATUS_FAIL; /* Start in fail state */ + + /* Init context with hmac flag set */ + IF_BC_FAIL(_bcInitSha256(&ctx, BCRYPT_ALG_HANDLE_HMAC_FLAG)) goto Exit; + + IF_BC_FAIL(_bcCreateHmac(&ctx, key)) goto Exit; + + IF_BC_FAIL(_bcHashData(&ctx, data)) goto Exit; + + IF_BC_FAIL(_bcFinishHash(&ctx, hmacOut32)) goto Exit; + + result = CSTATUS_OK; /* HMAC operation completed, so set success */ + + Exit: + + _bcDestroyCtx(&ctx); + + return result; + } + +#endif /* !_IMPL_CRYPTO_SHA256_HMAC */ + +/* +* Provide a fallback HKDF expand function using the +* HMAC function as a base. +*/ + +#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND + + #define _IMPL_CRYPTO_SHA256_HKDF_EXPAND _bcrypt_fallback_hkdf_expand + + cstatus_t _bcrypt_hkdf_update(void* ctx, const cspan_t* data) + { + DEBUG_ASSERT(ctx != NULL) + + BC_FAIL(_bcHashData((struct _bcrypt_ctx*)ctx, data)) + return CSTATUS_OK; + } + + cstatus_t _bcrypt_hkdf_finish(void* ctx, sha256_t hmacOut32) + { + DEBUG_ASSERT(ctx != NULL) + + BC_FAIL(_bcFinishHash((struct _bcrypt_ctx*)ctx, hmacOut32)) + return CSTATUS_OK; + } + + _IMPLSTB cstatus_t _bcrypt_fallback_hkdf_expand(const cspan_t* prk, const cspan_t* info, span_t* okm) + { + cstatus_t result; + struct _bcrypt_ctx ctx; + struct nc_hkdf_fn_cb_struct handler; + + handler.update = _bcrypt_hkdf_update; + handler.finish = _bcrypt_hkdf_finish; + + /* Init bcrypt */ + BC_FAIL(_bcInitSha256(&ctx, BCRYPT_ALG_HANDLE_HMAC_FLAG)) + + BC_FAIL(_bcCreateHmac(&ctx, prk)) + + /* + * NOTE! Hmac reusable flag must be set to allow for multiple + * calls to the finish function without losing the context. + */ + + result = hkdfExpandProcess(&handler, &ctx, info, okm); + + _bcDestroyCtx(&ctx); + + return result; + } + +#endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXPAND */ + +#endif /* _NC_IS_WINDOWS */ \ No newline at end of file diff --git a/src/providers/mbedtls.c b/src/providers/mbedtls.c new file mode 100644 index 0000000..df5201f --- /dev/null +++ b/src/providers/mbedtls.c @@ -0,0 +1,174 @@ +/* +* Copyright (c) 2024 Vaughn Nugent +* +* Package: noscrypt +* File: mbedtls.c +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public License +* as published by the Free Software Foundation; either version 2.1 +* of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with noscrypt. If not, see http://www.gnu.org/licenses/. +*/ + + +/* +* This file contains implemntation functions for the required +* cryptography primitives of noscrypt. This file stubs functionality +* using the Mbed-TLS library, if the builder desires to link against +* it. +*/ + +#ifdef MBEDTLS_CRYPTO_LIB + +/* Inline errors on linux in header files on linux */ +#ifndef inline + #define inline __inline + #include + #include + #include + #include + #include + #include + #undef inline +#else + #include + #include + #include + #include + #include + #include +#endif + +_IMPLSTB const mbedtls_md_info_t* _mbed_sha256_alg(void) +{ + const mbedtls_md_info_t* info; + /* Get sha256 md info for hdkf operations */ + info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); + DEBUG_ASSERT2(info != NULL, "Expected SHA256 md info pointer to be valid") + return info; +} + +#if SIZE_MAX < UINT64_MAX + #define _ssize_guard_int(x) if(x > SIZE_MAX) return 1; +#else + #define _ssize_guard_int(x) +#endif + +#ifndef _IMPL_CHACHA20_CRYPT + + /* Export chacha20 computation */ + #define _IMPL_CHACHA20_CRYPT _mbed_chacha20_encrypt + + _IMPLSTB cstatus_t _mbed_chacha20_encrypt( + const uint8_t* key, + const uint8_t* nonce, + const uint8_t* input, + uint8_t* output, + uint32_t dataLen + ) + { + _overflow_check(dataLen) + + /* Counter always starts at 0 */ + return mbedtls_chacha20_crypt( + key, + nonce, + 0x00u, /* nip-44 counter version */ + dataLen, + input, + output + ) == 0 ? CSTATUS_OK : CSTATUS_FAIL; + } + +#endif + +/* Export sha256 if not already defined */ +#ifndef _IMPL_CRYPTO_SHA256_DIGEST + + #define _IMPL_CRYPTO_SHA256_DIGEST _mbed_sha256_digest + + _IMPLSTB cstatus_t _mbed_sha256_digest(const cspan_t* data, sha256_t digestOut32) + { + _overflow_check(data->size) + + return mbedtls_sha256( + data->data, + data->size, + digestOut32, + 0 /* Set 0 for sha256 mode */ + ) == 0 ? CSTATUS_OK : CSTATUS_FAIL; + } + +#endif + +/* Export Sha256 hmac if not already defined by other libs */ +#ifndef _IMPL_CRYPTO_SHA256_HMAC + + #define _IMPL_CRYPTO_SHA256_HMAC _mbed_sha256_hmac + + _IMPLSTB cstatus_t _mbed_sha256_hmac(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32) + { + _overflow_check(data->size) + + /* Keys should never be large enough for this to matter, but sanity check. */ + DEBUG_ASSERT2(key->size < SIZE_MAX, "Expected key size to be less than SIZE_MAX") + + return mbedtls_md_hmac( + _mbed_sha256_alg(), + key->data, + key->size, + data->data, + data->size, + hmacOut32 + ) == 0 ? CSTATUS_OK : CSTATUS_FAIL; + } +#endif + +/* Export hkdf expand if not already defined */ +#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND + + #define _IMPL_CRYPTO_SHA256_HKDF_EXPAND _mbed_sha256_hkdf_expand + + _IMPLSTB cstatus_t _mbed_sha256_hkdf_expand(const cspan_t* prk, const cspan_t* info, span_t* okm) + { + /* These sizes should never be large enough to overflow on <64bit platforms, but sanity check */ + DEBUG_ASSERT(okm->size < SIZE_MAX) + DEBUG_ASSERT(prk->size < SIZE_MAX) + DEBUG_ASSERT(info->size < SIZE_MAX) + + return mbedtls_hkdf_expand( + _mbed_sha256_alg(), + prk->data, + prk->size, + info->data, + info->size, + okm->data, + okm->size + ) == 0 ? CSTATUS_OK : CSTATUS_FAIL; + } + +#endif + +/* Export fixed-time compare if not already defined */ +#ifndef _IMPL_CRYPTO_FIXED_TIME_COMPARE + + #define _IMPL_CRYPTO_FIXED_TIME_COMPARE _mbed_fixed_time_compare + + /* fixed-time memcmp */ + _IMPLSTB uint32_t _mbed_fixed_time_compare(const uint8_t* a, const uint8_t* b, uint32_t size) + { + _ssize_guard_int(size) + + return (uint32_t)mbedtls_ct_memcmp(a, b, size); + } +#endif + +#endif \ No newline at end of file diff --git a/src/providers/monocypher.c b/src/providers/monocypher.c new file mode 100644 index 0000000..8ffe048 --- /dev/null +++ b/src/providers/monocypher.c @@ -0,0 +1,78 @@ +/* +* Copyright (c) 2024 Vaughn Nugent +* +* Package: noscrypt +* File: impl/monocypher.c +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public License +* as published by the Free Software Foundation; either version 2.1 +* of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with noscrypt. If not, see http://www.gnu.org/licenses/. +*/ + + +/* +* This file handles some fallbacks that may not be available on +* some platforms. More specifically: +* - Secure memset 0 +* - Chacha20 cipher +* +*/ + +#ifdef NC_ENABLE_MONOCYPHER + +#include + +/* Export secure memse0 */ +#ifndef _IMPL_SECURE_ZERO_MEMSET + + /* export cytpo wipe function as is */ + #define _IMPL_SECURE_ZERO_MEMSET crypto_wipe +#endif + +/* Export Chacha20 */ +#ifndef _IMPL_CHACHA20_CRYPT + + #define _IMPL_CHACHA20_CRYPT _mc_chacha20_crypt + + _IMPLSTB cstatus_t _mc_chacha20_crypt( + const uint8_t* key, + const uint8_t* nonce, + const uint8_t* input, + uint8_t* output, + uint32_t dataLen + ) + { + _overflow_check(dataLen) + + /* + * Function returns the next counter value which is not + * needed for noscrypt as encryptions are one-shot, and + * require a new nonce for each encryption. + * + * ITEF function uses a 12byte nonce which is required for + * nip-44 compliant encryption. + */ + crypto_chacha20_ietf( + output, + input, + (size_t)dataLen, + key, + nonce, + 0x00 /* Counter always starts at 0 */ + ); + + return CSTATUS_OK; + } + +#endif + +#endif /* !NC_ENABLE_MONOCYPHER */ \ No newline at end of file diff --git a/src/providers/openssl.c b/src/providers/openssl.c new file mode 100644 index 0000000..1f31796 --- /dev/null +++ b/src/providers/openssl.c @@ -0,0 +1,233 @@ +/* +* Copyright (c) 2024 Vaughn Nugent +* +* Package: noscrypt +* File: impl/openssl.c +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public License +* as published by the Free Software Foundation; either version 2.1 +* of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with noscrypt. If not, see http://www.gnu.org/licenses/. +*/ + + +/* Setup openssl */ +#ifdef OPENSSL_CRYPTO_LIB + +#include + +#define _OSSL_FAIL(x) if(!(x)) return CSTATUS_FAIL; + +#ifndef _IMPL_SECURE_ZERO_MEMSET + + #define _IMPL_SECURE_ZERO_MEMSET _ossl_secure_zero_memset + + _IMPLSTB void _ossl_secure_zero_memset(void* ptr, size_t size) + { + _overflow_check(size) + + OPENSSL_cleanse(ptr, size); + } +#endif + +#ifndef _IMPL_CRYPTO_FIXED_TIME_COMPARE + + #define _IMPL_CRYPTO_FIXED_TIME_COMPARE _ossl_fixed_time_compare + + _IMPLSTB uint32_t _ossl_fixed_time_compare(const uint8_t* a, const uint8_t* b, uint32_t size) + { + int result; + + /* Size checks are required for platforms that have integer sizes under 32bit */ + _overflow_check(size) + + result = CRYPTO_memcmp(a, b, size); + + return (uint32_t)result; + } + +#endif /* _IMPL_CRYPTO_FIXED_TIME_COMPARE */ + + +#ifndef _IMPL_CRYPTO_SHA256_DIGEST + + #include + + #define _IMPL_CRYPTO_SHA256_DIGEST _ossl_sha256_digest + + _IMPLSTB cstatus_t _ossl_sha256_digest(const cspan_t* data, sha256_t digestOut32) + { + _overflow_check(data->size) + + _OSSL_FAIL(SHA256(data->data, data->size, digestOut32)) + + return CSTATUS_OK; + } + +#endif + +#ifndef _IMPL_CRYPTO_SHA256_HMAC + + #include + + /* Export function */ + #define _IMPL_CRYPTO_SHA256_HMAC _ossl_hmac_sha256 + + _IMPLSTB cstatus_t _ossl_hmac_sha256(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32) + { + unsigned int hmacLen; + + _overflow_check(key->size) + _overflow_check(data->size) + + hmacLen = sizeof(sha256_t); + + _OSSL_FAIL( + HMAC( + EVP_sha256(), + key->data, + key->size, + data->data, + data->size, + hmacOut32, + &hmacLen + ) + ) + + /* digest length should match the actual digest size */ + DEBUG_ASSERT(hmacLen == sizeof(sha256_t)) + + return CSTATUS_OK; + } + +#endif /* !_IMPL_CRYPTO_SHA256_HMAC */ + +#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND + + #include + + #define _IMPL_CRYPTO_SHA256_HKDF_EXPAND _ossl_sha256_hkdf_expand + + cstatus_t _ossl_hkdf_update(void* ctx, const cspan_t* data) + { + DEBUG_ASSERT(ctx != NULL) + + _overflow_check(data->size) + + _OSSL_FAIL(EVP_DigestUpdate((EVP_MD_CTX*)ctx, data->data, data->size)) + + return CSTATUS_OK; + } + + cstatus_t _ossl_hkdf_finish(void* ctx, sha256_t hmacOut32) + { + unsigned int hmacSize; + + DEBUG_ASSERT(ctx != NULL) + + hmacSize = sizeof(sha256_t); + + _OSSL_FAIL(EVP_DigestFinal_ex((EVP_MD_CTX*)ctx, hmacOut32, &hmacSize)) + + /* When configured for sha256, should always be the same size in/out */ + DEBUG_ASSERT(hmacSize == sizeof(sha256_t)) + + return CSTATUS_OK; + } + + _IMPLSTB cstatus_t _ossl_sha256_hkdf_expand(const cspan_t* prk, const cspan_t* info, span_t* okm) + { + EVP_MD_CTX* ctx; + cstatus_t result; + struct nc_hkdf_fn_cb_struct handler; + + result = CSTATUS_FAIL; + + /* + * NOTE! Hmac reusable flag must be set to allow for multiple + * calls to the finish function without losing the context. + */ + + if ((ctx = EVP_MD_CTX_create()) == NULL) + { + return CSTATUS_FAIL; + } + + if (!EVP_DigestInit_ex2(ctx, EVP_sha256(), NULL)) + { + goto Cleanup; + } + + if (!EVP_DigestUpdate(ctx, prk->data, prk->size)) + { + goto Cleanup; + } + + handler.update = _ossl_hkdf_update; + handler.finish = _ossl_hkdf_finish; + + result = hkdfExpandProcess(&handler, ctx, info, okm); + + Cleanup: + + EVP_MD_CTX_destroy(ctx); + + return result; + } + +#endif /* !_IMPL_CRYPTO_SHA256_HKDF_EXPAND */ + +#ifndef _IMPL_CHACHA20_CRYPT + + #include + + #define _IMPL_CHACHA20_CRYPT _ossl_chacha20_crypt + + _IMPLSTB cstatus_t _ossl_chacha20_crypt( + const uint8_t* key, + const uint8_t* nonce, + const uint8_t* input, + uint8_t* output, + uint32_t dataLen + ) + { + cstatus_t result; + EVP_CIPHER_CTX* ctx; + + result = CSTATUS_FAIL; + + if ((ctx = EVP_CIPHER_CTX_new()) == NULL) + { + return CSTATUS_FAIL; + } + + if (!EVP_EncryptInit_ex(ctx, EVP_chacha20(), NULL, key, nonce)) + { + goto Cleanup; + } + + if (!EVP_EncryptUpdate(ctx, output, (int*)&dataLen, input, dataLen)) + { + goto Cleanup; + } + + result = CSTATUS_OK; + + Cleanup: + + EVP_CIPHER_CTX_free(ctx); + + return result; + } + +#endif + +#endif /*!OPENSSL_CRYPTO_LIB */ \ No newline at end of file -- cgit