aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CHANGELOG.md5
-rw-r--r--Module.Taskfile.yaml1
-rw-r--r--Taskfile.yaml34
-rw-r--r--src/providers/openssl-helpers.c245
-rw-r--r--src/providers/openssl.c232
-rw-r--r--tests/test.c12
6 files changed, 406 insertions, 123 deletions
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 563b347..2398eaf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Added
- C# .NET 8.0 library wrapper for noscrypt
- Full NIP44 vector testing for encryption
+- Valgrind memory checking during unit testing
+- Added CI testing for Windows and Linux deployments
+
+### Fixed
+- Convert all OpenSSL apis to use the EVP api and unify it's usage. Also fixes some detected memory leaks that were undocumented.
## [0.1.5]
diff --git a/Module.Taskfile.yaml b/Module.Taskfile.yaml
index b7b991c..f5906aa 100644
--- a/Module.Taskfile.yaml
+++ b/Module.Taskfile.yaml
@@ -27,6 +27,7 @@ tasks:
cmds:
- cmd: task test -- -DNC_ENABLE_UTILS=ON
- cmd: wsl task test -- -DNC_ENABLE_UTILS=ON
+ - cmd: wsl task memcheck
#called by build pipeline to build module
build:
diff --git a/Taskfile.yaml b/Taskfile.yaml
index b19a135..ea12599 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -37,7 +37,19 @@ tasks:
cmds:
- task: build-debug
- cmd: cd {{ .CMAKE_BUILD_DIR }} && ctest -C Debug --verbose
-
+
+ dev:
+ watch: true
+ sources:
+ - include/*
+ - src/*
+ - src/*/*
+ - tests/*
+ - CMakelists.txt
+ - vendor/*
+ cmds:
+ - task: test-dev
+
test-mbedtls:
desc: "Builds and runs tests for noscrypt using the mbedtls crypto library for the current platform"
cmds:
@@ -55,6 +67,7 @@ tasks:
- task: compile
vars: { BUILD_CONFIG: 'Debug' }
- cmd: cd {{ .CMAKE_BUILD_DIR }} && ctest -C Debug --verbose --output-on-failure
+ - task: memcheck
build-internal:
internal: true
@@ -84,7 +97,24 @@ tasks:
- cmd: echo "Installing noscrypt globally"
silent: true
- cmd: cmake --install {{ .CMAKE_BUILD_DIR }} {{ .CLI_ARGS }}
-
+
+ #Test executable and library must be built for tests to run
+ memcheck:
+ desc: 'Runs Valgrind memcheck in debug mode against the nctest executable (Linux only)'
+ platforms:
+ - linux
+ preconditions:
+ - which valgrind
+ cmds:
+ - cmd: echo "Running valgrind memory check on test executable"
+ silent: true
+ - cmd:
+ valgrind
+ --tool=memcheck
+ --leak-check=full
+ --show-leak-kinds=all
+ --track-origins=yes
+ {{ .CMAKE_BUILD_DIR }}/{{ .TEST_EXE_NAME }}
#CI ONLY!!
diff --git a/src/providers/openssl-helpers.c b/src/providers/openssl-helpers.c
new file mode 100644
index 0000000..42e98c3
--- /dev/null
+++ b/src/providers/openssl-helpers.c
@@ -0,0 +1,245 @@
+/*
+* Copyright (c) 2024 Vaughn Nugent
+*
+* Package: noscrypt
+* File: providers/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/.
+*/
+
+
+#include <openssl/crypto.h>
+#include <openssl/evp.h>
+
+#define OSSL_SHA256 "SHA2-256"
+#define OSSL_HMAC "hmac"
+#define ossl_evp_fetch_chacha20() EVP_CIPHER_fetch(NULL, "ChaCha20", NULL)
+
+
+typedef enum {
+
+ EvpStateTypeDigest,
+
+ EvpStateTypeMac
+
+} _evp_state_type;
+
+struct ossl_evp_state {
+ void* _context;
+ void* _providerHandle;
+
+ OSSL_PARAM params[2];
+
+ _evp_state_type type;
+
+ cspan_t _prk;
+};
+
+
+_IMPLSTB EVP_MAC_CTX* _osslEvpGetMacContext(const struct ossl_evp_state* state)
+{
+ DEBUG_ASSERT(state != NULL);
+ DEBUG_ASSERT(state->type == EvpStateTypeMac);
+
+ return (EVP_MAC_CTX*)state->_context;
+}
+
+_IMPLSTB EVP_MD_CTX* _osslEvpGetMdContext(const struct ossl_evp_state* state)
+{
+ DEBUG_ASSERT(state != NULL);
+ DEBUG_ASSERT(state->type == EvpStateTypeDigest);
+
+ return (EVP_MD_CTX*)state->_context;
+}
+
+_IMPLSTB cspan_t _osslEvpGetPrk(const struct ossl_evp_state* state)
+{
+ DEBUG_ASSERT(state != NULL);
+
+ return state->_prk;
+}
+
+_IMPLSTB void _osslEvpSetPrk(struct ossl_evp_state* state, cspan_t prk)
+{
+ DEBUG_ASSERT(state != NULL);
+
+ state->_prk = prk;
+}
+
+_IMPLSTB cstatus_t _osslEvpUpdate(const struct ossl_evp_state* state, cspan_t data)
+{
+ int result;
+
+ DEBUG_ASSERT(state != NULL);
+ DEBUG_ASSERT(state->_context != NULL);
+
+ result = 0;
+
+ switch (state->type)
+ {
+ case EvpStateTypeDigest:
+ result = EVP_DigestUpdate(
+ _osslEvpGetMdContext(state),
+ ncSpanGetOffsetC(data, 0),
+ ncSpanGetSizeC(data)
+ );
+ break;
+
+ case EvpStateTypeMac:
+ result = EVP_MAC_update(
+ _osslEvpGetMacContext(state),
+ ncSpanGetOffsetC(data, 0),
+ ncSpanGetSizeC(data)
+ );
+ break;
+
+ }
+
+ return (cstatus_t)(result != 0);
+}
+
+_IMPLSTB cstatus_t _osslEvpFinal(const struct ossl_evp_state* state, span_t out)
+{
+ int result;
+ size_t hmacLen;
+ unsigned int mdLen;
+
+ DEBUG_ASSERT(state != NULL);
+
+ result = 0;
+ mdLen = hmacLen = ncSpanGetSize(out);
+
+ switch (state->type)
+ {
+ case EvpStateTypeDigest:
+ result = EVP_DigestFinal_ex(
+ _osslEvpGetMdContext(state),
+ ncSpanGetOffset(out, 0),
+ &mdLen
+ );
+
+ return (cstatus_t)(result != 0 && mdLen == ncSpanGetSize(out));
+
+ case EvpStateTypeMac:
+ result = EVP_MAC_final(
+ _osslEvpGetMacContext(state),
+ ncSpanGetOffset(out, 0),
+ &hmacLen,
+ hmacLen
+ );
+ return (cstatus_t)(result != 0 && hmacLen == ncSpanGetSize(out));
+ }
+
+ /*
+ * If the result is non-zero and the hash length is equal to the output
+ * buffer size, return success, otherwise return failure.
+ */
+
+ return CSTATUS_FAIL;
+}
+
+_IMPLSTB cstatus_t _osslEvpMacInit(const struct ossl_evp_state* state)
+{
+ int result;
+
+ DEBUG_ASSERT(state != NULL);
+ DEBUG_ASSERT(state->type == EvpStateTypeMac);
+ DEBUG_ASSERT(ncSpanIsValidC(state->_prk));
+
+ result = EVP_MAC_init(
+ _osslEvpGetMacContext(state),
+ ncSpanGetOffsetC(state->_prk, 0),
+ ncSpanGetSizeC(state->_prk),
+ state->params
+ );
+
+ return (cstatus_t)(result != 0);
+}
+
+_IMPLSTB void _osslEvpFree(struct ossl_evp_state* state)
+{
+ DEBUG_ASSERT(state != NULL);
+
+ switch (state->type)
+ {
+ case EvpStateTypeDigest:
+ if (state->_context) EVP_MD_CTX_free(state->_context);
+ if (state->_providerHandle) EVP_MD_free(state->_providerHandle);
+ break;
+ case EvpStateTypeMac:
+ if (state->_context) EVP_MAC_CTX_free(state->_context);
+ if (state->_providerHandle) EVP_MAC_free(state->_providerHandle);
+ break;
+ }
+}
+
+_IMPLSTB cstatus_t _osslEvpInit(
+ struct ossl_evp_state* state,
+ _evp_state_type type,
+ const char* providerName
+)
+{
+ DEBUG_ASSERT(state != NULL);
+ DEBUG_ASSERT(providerName != NULL);
+
+ state->type = type;
+
+ switch (type)
+ {
+ case EvpStateTypeDigest:
+ state->_providerHandle = EVP_MD_fetch(NULL, providerName, NULL);
+ state->_context = EVP_MD_CTX_new();
+ break;
+ case EvpStateTypeMac:
+
+ state->_providerHandle = EVP_MAC_fetch(NULL, providerName, NULL);
+
+ if (state->_providerHandle)
+ {
+ state->_context = EVP_MAC_CTX_new((EVP_MAC*)(state->_providerHandle));
+ }
+
+ break;
+ default:
+ return CSTATUS_FAIL;
+ }
+
+ /*
+ * Ensure allocations succeded, otherwise free the context
+ * and return a failure status.
+ */
+ if (state->_providerHandle == NULL || state->_context == NULL)
+ {
+ return CSTATUS_FAIL;
+ }
+
+ /*
+ * If the type is a digest, initialize the digest context
+ */
+ if (type == EvpStateTypeDigest)
+ {
+ if (
+ !EVP_DigestInit_ex(
+ (EVP_MD_CTX*)state->_context,
+ (EVP_MD*)state->_providerHandle,
+ NULL
+ )
+ )
+ {
+ return CSTATUS_FAIL;
+ }
+ }
+
+ return CSTATUS_OK;
+}
diff --git a/src/providers/openssl.c b/src/providers/openssl.c
index c2933fb..4b41f1a 100644
--- a/src/providers/openssl.c
+++ b/src/providers/openssl.c
@@ -22,13 +22,7 @@
/* Setup openssl */
#ifdef OPENSSL_CRYPTO_LIB
-#include <openssl/crypto.h>
-
-#define _OSSL_FAIL(x) if(!(x)) return CSTATUS_FAIL;
-
-#define ossl_md_sha256() EVP_MD_fetch(NULL, "SHA2-256", NULL)
-#define ossl_evp_fetch_chacha20() EVP_CIPHER_fetch(NULL, "ChaCha20", NULL)
-#define ossl_mac_fetch_hmac() EVP_MAC_fetch(NULL, "hmac", NULL)
+#include "openssl-helpers.c"
#ifndef _IMPL_SECURE_ZERO_MEMSET
@@ -63,156 +57,163 @@
#ifndef _IMPL_CRYPTO_SHA256_DIGEST
- #include <openssl/sha.h>
-
#define _IMPL_CRYPTO_SHA256_DIGEST _ossl_sha256_digest
_IMPLSTB cstatus_t _ossl_sha256_digest(cspan_t data, sha256_t digestOut32)
{
- _overflow_check(data.size);
+ cstatus_t result;
+ span_t digestSpan;
+ struct ossl_evp_state evpState;
+
DEBUG_ASSERT(digestOut32 != NULL);
DEBUG_ASSERT(ncSpanIsValidC(data));
- _OSSL_FAIL(
- SHA256(
- ncSpanGetOffsetC(data, 0),
- ncSpanGetSizeC(data),
- digestOut32
- )
- );
+ result = CSTATUS_FAIL;
+
+ _overflow_check(data.size);
+
+ ncSpanInit(&digestSpan, digestOut32, sizeof(sha256_t));
+
+ /*
+ * Allocate and initalize the context
+ */
+ if (!_osslEvpInit(&evpState, EvpStateTypeDigest, OSSL_SHA256))
+ {
+ goto Cleanup;
+ }
+
+ if (!_osslEvpUpdate(&evpState, data))
+ {
+ goto Cleanup;
+ }
+
+ if (!_osslEvpFinal(&evpState, digestSpan))
+ {
+ goto Cleanup;
+ }
+
+ result = CSTATUS_OK;
+
+ Cleanup:
+
+ _osslEvpFree(&evpState);
- return CSTATUS_OK;
+ return result;
}
#endif
#ifndef _IMPL_CRYPTO_SHA256_HMAC
- #include <openssl/hmac.h>
-
/* Export function */
#define _IMPL_CRYPTO_SHA256_HMAC _ossl_hmac_sha256
_IMPLSTB cstatus_t _ossl_hmac_sha256(cspan_t key, cspan_t data, sha256_t hmacOut32)
{
- unsigned int hmacLen;
+ cstatus_t result;
+ span_t digestSpan;
+ struct ossl_evp_state evpState;
+
+ result = CSTATUS_FAIL;
_overflow_check(key.size)
_overflow_check(data.size)
- hmacLen = sizeof(sha256_t);
-
- _OSSL_FAIL(
- HMAC(
- ossl_md_sha256(),
- ncSpanGetOffsetC(key, 0),
- ncSpanGetSizeC(key),
- ncSpanGetOffsetC(data, 0),
- ncSpanGetSizeC(data),
- hmacOut32,
- &hmacLen
- )
- );
-
- /* digest length should match the actual digest size */
- DEBUG_ASSERT(hmacLen == sizeof(sha256_t));
+ ncSpanInit(&digestSpan, hmacOut32, sizeof(sha256_t));
- return CSTATUS_OK;
- }
+ /*
+ * Allocate and initalize the context
+ */
+ if (!_osslEvpInit(&evpState, EvpStateTypeMac, OSSL_HMAC))
+ {
+ goto Cleanup;
+ }
-#endif /* !_IMPL_CRYPTO_SHA256_HMAC */
+ /*
+ * To use HMAC the digest parameters must be set
+ * before the context can be initialized
+ */
-#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND
+ evpState.params[0] = OSSL_PARAM_construct_utf8_string("digest", "sha256", 0);
+ evpState.params[1] = OSSL_PARAM_construct_end();
+
+ /*
+ * PRK Data must be assigned before the hmac
+ * can be initialized
+ */
+
+ _osslEvpSetPrk(&evpState, key);
- #include <openssl/evp.h>
+ if (!_osslEvpMacInit(&evpState))
+ {
+ goto Cleanup;
+ }
- #define _IMPL_CRYPTO_SHA256_HKDF_EXPAND _ossl_sha256_hkdf_expand
+ if (!_osslEvpUpdate(&evpState, data))
+ {
+ goto Cleanup;
+ }
- struct ossl_hmac_state {
- EVP_MAC_CTX* libCtx;
- OSSL_PARAM params[2];
- cspan_t prk;
- };
+ if (!_osslEvpFinal(&evpState, digestSpan))
+ {
+ goto Cleanup;
+ }
+
+ result = CSTATUS_OK;
- static cstatus_t _ossl_hmac_init(const struct ossl_hmac_state* osslCtx)
- {
- DEBUG_ASSERT(ncSpanIsValidC(osslCtx->prk));
- DEBUG_ASSERT(osslCtx->params != NULL);
-
- _OSSL_FAIL(
- EVP_MAC_init(
- osslCtx->libCtx,
- ncSpanGetOffsetC(osslCtx->prk, 0),
- ncSpanGetSizeC(osslCtx->prk),
- osslCtx->params
- )
- );
+ Cleanup:
+
+ _osslEvpFree(&evpState);
+
+ return result;
- return CSTATUS_OK;
}
+#endif /* !_IMPL_CRYPTO_SHA256_HMAC */
+
+#ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND
+
+ #define _IMPL_CRYPTO_SHA256_HKDF_EXPAND _ossl_sha256_hkdf_expand
+
static cstatus_t _ossl_hkdf_update(void* ctx, cspan_t data)
{
- const struct ossl_hmac_state* osslCtx;
-
DEBUG_ASSERT(ctx != NULL);
_overflow_check(data.size);
- osslCtx = (const struct ossl_hmac_state*)ctx;
-
- DEBUG_ASSERT(osslCtx->libCtx != NULL);
-
- _OSSL_FAIL(
- EVP_MAC_update(
- osslCtx->libCtx,
- ncSpanGetOffsetC(data, 0),
- ncSpanGetSizeC(data)
- )
+ return _osslEvpUpdate(
+ (const struct ossl_evp_state*)ctx,
+ data
);
-
- return CSTATUS_OK;
}
static cstatus_t _ossl_hkdf_finish(void* ctx, sha256_t hmacOut32)
{
- const struct ossl_hmac_state* osslCtx;
- size_t hmacSize;
+ span_t hmacSpan;
DEBUG_ASSERT(ctx != NULL);
DEBUG_ASSERT(hmacOut32 != NULL);
- osslCtx = (const struct ossl_hmac_state*)ctx;
- hmacSize = 0;
-
- DEBUG_ASSERT(osslCtx->libCtx != NULL);
-
- _OSSL_FAIL(
- EVP_MAC_final(
- osslCtx->libCtx,
- hmacOut32,
- &hmacSize,
- sizeof(sha256_t)
- )
- );
+ ncSpanInit(&hmacSpan, hmacOut32, sizeof(sha256_t));
- /* When configured for sha256, should always be the same size in/out */
- DEBUG_ASSERT(hmacSize == sizeof(sha256_t));
+ if (!_osslEvpFinal((const struct ossl_evp_state*)ctx, hmacSpan))
+ {
+ return CSTATUS_FAIL;
+ }
/*
* Context must be re-initalized after finalize
* See lifecycle https://docs.openssl.org/3.0/man7/life_cycle-mac/#copyright
*/
- return _ossl_hmac_init(osslCtx);
+ return _osslEvpMacInit((const struct ossl_evp_state*)ctx);
}
_IMPLSTB cstatus_t _ossl_sha256_hkdf_expand(cspan_t prk, cspan_t info, span_t okm)
{
- EVP_MAC* mac;
cstatus_t result;
- struct ossl_hmac_state hkdfState;
+ struct ossl_evp_state hkdfState;
struct nc_hkdf_fn_cb_struct handler;
result = CSTATUS_FAIL;
@@ -224,45 +225,40 @@
_overflow_check(info.size);
_overflow_check(okm.size);
- hkdfState.params[0] = OSSL_PARAM_construct_utf8_string("digest", "sha256", 0);
- hkdfState.params[1] = OSSL_PARAM_construct_end();
-
- hkdfState.prk = prk;
-
/*
- * Silly openssl stuff. Enable hmac with sha256 using the system default
- * security provider. The one-shot flag must also be disabled (0) because
- * we need to call update multiple times.
+ * PRK Must be set before any call to MacInit
+ *
+ * Params must also be set for sha256 digest for mac
*/
+ _osslEvpSetPrk(&hkdfState, prk);
- mac = ossl_mac_fetch_hmac();
+ hkdfState.params[0] = OSSL_PARAM_construct_utf8_string("digest", "sha256", 0);
+ hkdfState.params[1] = OSSL_PARAM_construct_end();
- if (mac == NULL)
+ if (!_osslEvpInit(&hkdfState, EvpStateTypeMac, OSSL_HMAC))
{
goto Cleanup;
}
- hkdfState.libCtx = EVP_MAC_CTX_new(mac);
-
- if (hkdfState.libCtx == NULL)
- {
- goto Cleanup;
- }
+ /*
+ * Silly openssl stuff. Enable hmac with sha256 using the system default
+ * security provider. The one-shot flag must also be disabled (0) because
+ * we need to call update multiple times.
+ */
- if (_ossl_hmac_init(&hkdfState) != CSTATUS_OK)
+ if (_osslEvpMacInit(&hkdfState) != CSTATUS_OK)
{
goto Cleanup;
}
- DEBUG_ASSERT(EVP_MAC_CTX_get_mac_size(hkdfState.libCtx) == sizeof(sha256_t));
+ DEBUG_ASSERT(EVP_MAC_CTX_get_mac_size(_osslEvpGetMacContext(&hkdfState)) == sizeof(sha256_t));
/* Pass the library */
result = hkdfExpandProcess(&handler, &hkdfState, info, okm);
Cleanup:
-
- if (hkdfState.libCtx) EVP_MAC_CTX_free(hkdfState.libCtx);
- if (mac) EVP_MAC_free(mac);
+
+ _osslEvpFree(&hkdfState);
return result;
}
@@ -271,8 +267,6 @@
#ifndef _IMPL_CHACHA20_CRYPT
- #include <openssl/evp.h>
-
#define _IMPL_CHACHA20_CRYPT _ossl_chacha20_crypt
_IMPLSTB cstatus_t _ossl_cipher_core(
diff --git a/tests/test.c b/tests/test.c
index 20a0e5d..e8ce756 100644
--- a/tests/test.c
+++ b/tests/test.c
@@ -507,8 +507,16 @@ static int TestPublicApiArgumentValidation()
macArgs.payloadSize = 0;
TEST(NCVerifyMac(ctx, &secKey, &pubKey, &macArgs), ARG_RANGE_ERROR_POS_3)
}
-
- PRINTL("\nPASSED: Public API argument validation tests completed")
+
+ ENSURE(NCDestroyContext(ctx) == NC_SUCCESS);
+
+#ifdef NOSCRYPTUTIL_H
+ NCUtilContextFree(ctx);
+#else
+ free(ctx);
+#endif
+
+ PRINTL("\nPASSED: Public API argument validation tests completed");
return 0;
}
generated by cgit (git 2.46.0) at 2024-11-16 19:02:21 +0000