Squashed commit of the following:

commit 942aed8a4e7c173a2c9423829c2b38087cbd49e4 Author: vnugent <public@vaughnnugent.com> Date: Tue Aug 6 20:54:03 2024 -0400 chore: update changelog and mbedtls headers commit 3b97f84fd0477eafcd6567eb8597b213e4136664 Author: vnugent <public@vaughnnugent.com> Date: Tue Aug 6 19:57:10 2024 -0400 update libsecp256k1 to v0.5.1 commit 7989a2660997b909e0b99fc1dfb3bcfbb0528df3 Author: vnugent <public@vaughnnugent.com> Date: Tue Aug 6 19:42:25 2024 -0400 update openssl to 3.3.1 commit e949ae5aa1fd25d4d11fe31e30b7d82ae7778dc2 Author: vnugent <public@vaughnnugent.com> Date: Mon Aug 5 18:01:03 2024 -0400 fix: Find and fix openssl encryption bug commit a60a3e1ca1d99d655c0cfc96e3952c371e8a8677 Author: vnugent <public@vaughnnugent.com> Date: Sun Aug 4 15:27:06 2024 -0400 cleanup comments + return codes commit 2aa7f4b6cdb2e0e8990e7177476f4104fd2e2b17 Author: vnugent <public@vaughnnugent.com> Date: Sat Jul 27 22:20:53 2024 -0400 fix codeberg url commit 1640f79776c6b291b49a39a6128c05888fc4153e Author: vnugent <public@vaughnnugent.com> Date: Sat Jul 27 00:05:07 2024 -0400 fix: Potential overflow in nip44 padding calculation commit 07de078a3b5b7b0043d9f81bb5a9e750a3a0c7c1 Author: vnugent <public@vaughnnugent.com> Date: Fri Jul 26 23:37:15 2024 -0400 refactor: Span invasion, checks and fix some evp api commit 54f520e4bfc0fe23e2719d44b09739aa8709451c Author: vnugent <public@vaughnnugent.com> Date: Tue Jul 23 19:55:13 2024 -0400 latest changes commit 12feb33dba2061415d6f39fa59dec16fafcda2a0 Author: vnugent <public@vaughnnugent.com> Date: Sun Jul 21 17:51:04 2024 -0400 Push latest changes, patches, and internal upgrades commit ffe42b6858f112a00405be4f0605ab1163063749 Author: vnugent <public@vaughnnugent.com> Date: Sat Jul 13 22:13:13 2024 -0400 test: Add decryption test cases and fixes commit 5dfafbc5a9214587533ec8b1dae2a962118d3650 Author: vnugent <public@vaughnnugent.com> Date: Fri Jul 12 22:14:00 2024 -0400 feat: add decryption functionality to public api commit 8df8c5aed4ac626171b451b5422c3b207e88000b Author: vnugent <public@vaughnnugent.com> Date: Thu Jul 11 21:39:39 2024 -0400 feat: Update sidecar utils library commit 23fe6e8c8596333c2183f0f4389817087442c551 Author: vnugent <public@vaughnnugent.com> Date: Fri Jul 5 00:03:48 2024 -0400 push latest utils and changes commit dc71f861df8929deee300368b88ef47d45560695 Author: vnugent <public@vaughnnugent.com> Date: Mon Jul 1 15:05:34 2024 -0400 fix: #7 fix confusing inline functions commit 90166048046d2511f0bb74f8880180e82466d4c0 Author: vnugent <public@vaughnnugent.com> Date: Tue Jun 18 21:22:37 2024 -0400 push pending changes commit 461dd71069d0c0250752ac1256160605c33a6243 Author: vnugent <public@vaughnnugent.com> Date: Tue Jun 11 15:44:28 2024 -0400 feat!: #4 Close #4. Add public nip04 support to api commit a74f96251bcc81fb2c94fe75dd6f8043fd35fe0b Merge: 1c26ef8 51d0aff Author: vnugent <public@vaughnnugent.com> Date: Wed May 29 13:37:00 2024 -0400 Merge branch 'master' into develop commit 1c26ef86a04690120f4f752c7c5018a570ec5880 Author: vnugent <public@vaughnnugent.com> Date: Wed May 29 13:34:20 2024 -0400 missed extra argument commit 88c9095743a12cf8fc1793c607ba3a1e4fa86483 Author: vnugent <public@vaughnnugent.com> Date: Wed May 29 13:25:51 2024 -0400 refactor!: return NC_SUCCESS when validating secret key commit 718be80a4810b9352de7eb0707da54020aa6b649 Author: vnugent <public@vaughnnugent.com> Date: Mon May 27 14:52:41 2024 -0400 fix: Properly build mbedtls & cmake fixes commit a8a6efb2319f739e5faae550561dc27d9dd1e88d Author: vnugent <public@vaughnnugent.com> Date: Sun May 26 17:39:40 2024 -0400 chore: Update libs, reorder files, internalize private headers commit 72e1b7be4031e2fd4d258fcf434ad049c0029201 Author: vnugent <public@vaughnnugent.com> Date: Sun May 26 13:39:08 2024 -0400 fix: Add c++ extern prototypes in noscrypt.h commit aeaac8d328b75911541be64d6f09d58fca294a08 Author: vnugent <public@vaughnnugent.com> Date: Sun May 26 11:47:17 2024 -0400 refactor: Dep update, openssl chacha20 added commit 86b02540cce6015cfe4a2a56499a9a2f45d4e368 Author: vnugent <public@vaughnnugent.com> Date: Sat May 18 12:24:17 2024 -0400 refactor: Remove NCContext structure definition commit d09d9330415d463ca19be9394b02ce11b3366f7e Author: vnugent <public@vaughnnugent.com> Date: Mon May 13 22:33:50 2024 -0400 fix: update mbedtls inline issue includes commit 7838cb4bb15d4f453f92f56ece75e2b03986fe42 Author: vnugent <public@vaughnnugent.com> Date: Mon May 13 22:29:16 2024 -0400 fix: force fPIC for secp256k1 targets commit d76f7708bc6ae81a638ca708230ac9153ac754e2 Merge: aa8033d a526139 Author: vnugent <public@vaughnnugent.com> Date: Sun May 12 00:37:01 2024 -0400 Merge branch 'master' into develop commit aa8033d4dbfebeb72b6fd7a0cd218ebde0eb54dd Author: vnugent <public@vaughnnugent.com> Date: Sun May 12 00:34:20 2024 -0400 Final overview and test before tag commit 4e3ead2cf1d3068e77f0959dfdc17e20e9102a0f Merge: 2cee801 872c49d Author: vnugent <public@vaughnnugent.com> Date: Mon May 6 22:08:09 2024 -0400 Merge branch 'master' into develop commit 2cee801979bfbcb3b0e53f592ce8c779b57cb679 Author: vnugent <public@vaughnnugent.com> Date: Mon May 6 22:02:39 2024 -0400 Ensure static and dynamic libs get same args commit f533694023133552d0d42933d779c95a5854343f Author: vnugent <public@vaughnnugent.com> Date: Mon May 6 21:50:29 2024 -0400 feat: CMake install & fetch-content test & updates commit 940ff20348b13d0bc30d9e9f4289dd6de20b16ba Author: vnugent <public@vaughnnugent.com> Date: Sun May 5 14:07:28 2024 -0400 codeberg readonly push commit b34ed055c0b7d143561ce8798e0a95313b9224bd Merge: 0a40e20 e737556 Author: vnugent <public@vaughnnugent.com> Date: Sat May 4 14:06:45 2024 -0400 Merge branch 'master' into develop commit 0a40e209d03e8ff9b6f81cd5969d3e845c633bfc Author: vnugent <public@vaughnnugent.com> Date: Sat May 4 13:55:19 2024 -0400 ci: Force disable testing for win ci builds commit 55fae189fffc86f07a3448370f0a746670819712 Author: vnugent <public@vaughnnugent.com> Date: Thu May 2 21:54:35 2024 -0400 feat: Working and tested openssl impl & defaults commit 6ff8bb11774c51fd341b7699a3938fd894995fbf Author: vnugent <public@vaughnnugent.com> Date: Thu Apr 25 17:45:42 2024 -0400 refactor: Finish support and testing for mbedtls commit 7cb7a93de4f6f5e741bc5129e3d928e44f050930 Author: vnugent <public@vaughnnugent.com> Date: Tue Apr 23 18:19:31 2024 -0400 refactor!: MbedTLS on Windows, switch to uint32 commit 30e8dda6cbea86bdee6d5dfe48514385d3b9f81b Author: vnugent <public@vaughnnugent.com> Date: Tue Apr 23 14:48:05 2024 -0400 refactor: Crypto dep redesign working on Windows commit d09c6c1bd5da3e2d79351daeba304ca99976a726 Author: vnugent <public@vaughnnugent.com> Date: Thu Apr 18 00:28:51 2024 -0400 refactor!: Pushing what I have to dev commit 54e06ada7d624ed0d28c6a6db04a149708841bf8 Author: vnugent <public@vaughnnugent.com> Date: Sat Apr 13 01:24:00 2024 -0400 fix: convert constants to hex, inline macro, ParseErrorCode commit 4215e3100d9a0d23119080d09638fa5b60d0c6d4 Merge: d3328f4 7485aa5 Author: vnugent <public@vaughnnugent.com> Date: Wed Apr 3 18:26:30 2024 -0400 Merge branch 'master' into develop commit d3328f4152b22b28f24c43dda62464287f1efff5 Author: vnugent <public@vaughnnugent.com> Date: Wed Apr 3 18:22:56 2024 -0400 build: Included dependency and versions in client builds commit b11bc0bac955fd5c6db65f0da48456bf5e748805 Author: vnugent <public@vaughnnugent.com> Date: Wed Apr 3 18:10:08 2024 -0400 fix: Fix c89 compatabilty comments and struct assignment commit 9915bd41799a72413e6b400e150aa9f5fa797e25 Merge: 8e3d6ea 5184d7d Author: vnugent <public@vaughnnugent.com> Date: Sat Mar 30 09:57:30 2024 -0400 Merge branch 'master' into develop commit 8e3d6ea5e3c83fe42cb904b6ccc4fe2b73f76aae Author: vnugent <public@vaughnnugent.com> Date: Sat Mar 30 09:52:55 2024 -0400 refactor!: Some api (struct) changes and updated tests commit e88e8420520204e20802516f01d4488bb0b1d6ea Merge: 490dfee 21f6c0a Author: vnugent <public@vaughnnugent.com> Date: Sun Mar 3 15:02:34 2024 -0500 Merge branch 'master' into develop commit 490dfee4ef22479009627435c6ad728c3cbbab54 Author: vnugent <public@vaughnnugent.com> Date: Sun Mar 3 14:59:25 2024 -0500 test: #3 tests for encryption/description and Macs commit efa97490b7ed47f4e2f05bee52e2b33e14e439e6 Merge: 1b84e3c 120022a Author: vnugent <public@vaughnnugent.com> Date: Sun Mar 3 14:55:48 2024 -0500 merge master commit 1b84e3c7c2e55b1ff9ffdd09b66873e11c131441 Author: vnugent <public@vaughnnugent.com> Date: Sat Mar 2 22:57:36 2024 -0500 fix: #2 constent usage of sizeof() operator on struct types commit 9de5a214c66adea0ef2d0bac63c59449de202a88 Author: vnugent <public@vaughnnugent.com> Date: Fri Mar 1 14:30:36 2024 -0500 perf: avoid nc_key struct copy, cast and verify instead commit b917b761120ed684af28d0707673ffadcf14b8fe Author: vnugent <public@vaughnnugent.com> Date: Mon Feb 12 22:06:50 2024 -0500 fix: found the constant time memcompare function commit 9f85fff3b9f25da7410569ea94f994b88feb3910 Author: vnugent <public@vaughnnugent.com> Date: Fri Feb 9 22:48:35 2024 -0500 feat: added/update MAC functions to sign or verify nip44 payload commit aa5113741bb419b02d6ea416bba571fa3d65db46 Author: vnugent <public@vaughnnugent.com> Date: Wed Feb 7 01:37:53 2024 -0500 add missing hmac-key output buffer commit 55f47d22cc9ce4d1e22b70814d608c7ef3b1bbc9 Author: vnugent <public@vaughnnugent.com> Date: Sun Feb 4 21:08:13 2024 -0500 simple bug fixes, and public api argument validation tests commit 73c5a713fb164ae8b4ac8a891a8020e08eae0a3b Author: vnugent <public@vaughnnugent.com> Date: Fri Feb 2 23:05:48 2024 -0500 update api to return secpvalidate return code instead of internal return codes commit 06c73004e1a39a7ea4ea3a89c22dee0f66adb236 Author: vnugent <public@vaughnnugent.com> Date: Fri Feb 2 19:25:17 2024 -0500 change to lgpl license commit 6e79fdb3b6b6739fc7797d47e55a7691306cf736 Author: vnugent <public@vaughnnugent.com> Date: Wed Jan 31 21:30:49 2024 -0500 move validation macros, and optionally disable them commit ac1e58837f1ba687939f78b5c03cadd346c10ddd Author: vnugent <public@vaughnnugent.com> Date: Tue Jan 30 12:25:05 2024 -0500 couple more tests, renable range checks, set flags for all projects
author: vnugent <public@vaughnnugent.com> 2024-08-06 20:56:36 -0400
committer: vnugent <public@vaughnnugent.com> 2024-08-06 20:56:36 -0400
commit: 6fdc4bc32ccf653734cccb6e09690cb2973af6d0 (patch)
tree: 90ccef1e5edf4d48f36736dfa8c0973bfed106d8 /src
parent: 51d0aff9166ddaa3c74dbc2d7c1dcbdefa8405e1 (diff)
11 files changed, 1716 insertions, 210 deletions
diff --git a/src/hkdf.c b/src/hkdf.c
index 0d91d14..7b0b822 100644
--- a/src/hkdf.c
+++ b/src/hkdf.c
@@ -21,23 +21,10 @@
 
 #include "hkdf.h"
 
-/* Include string for memmove */
-#include <string.h>
-
 #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)
@@ -55,16 +42,15 @@ static _nc_fn_inline void debugValidateHandler(const struct nc_hkdf_fn_cb_struct
 cstatus_t hkdfExpandProcess(
 	const struct nc_hkdf_fn_cb_struct* handler,
 	void* ctx,
-	const cspan_t* info,
-	span_t* okm
+	cspan_t info,
+	span_t okm
 )
 {
 	cstatus_t result;
-
-	uint8_t counter;
+	cspan_t tSpan, counterSpan;
 	uint32_t tLen, okmOffset;
+	uint8_t counter[1];
 	uint8_t t[HKDF_IN_BUF_SIZE];
-	cspan_t tSpan, counterSpan;
 
 	debugValidateHandler(handler);
 
@@ -72,18 +58,18 @@ cstatus_t hkdfExpandProcess(
 
 	tLen = 0;				/* T(0) is an empty string(zero length) */
 	okmOffset = 0;
-	counter = 1;			/* counter is offset by 1 for init */
+	counter[0] = 1;			/* counter is offset by 1 for init */
 	result = CSTATUS_FAIL;	/* Start in fail state */
 
-	/* counter as a span */
-	ncSpanInitC(&counterSpan, &counter, sizeof(counter));
+	/* span over counter value that points to the counter buffer */
+	ncSpanInitC(&counterSpan, counter, sizeof(counter));
 
 	/* Compute T(N) = HMAC(prk, T(n-1) | info | n) */
-	while (okmOffset < okm->size)
+	while (okmOffset < okm.size)
 	{
 		ncSpanInitC(&tSpan, t, tLen);
 
-		if (handler->update(ctx, &tSpan) != CSTATUS_OK)
+		if (handler->update(ctx, tSpan) != CSTATUS_OK)
 		{
 			goto Exit;
 		}
@@ -93,7 +79,7 @@ cstatus_t hkdfExpandProcess(
 			goto Exit;
 		}
 
-		if (handler->update(ctx, &counterSpan) != CSTATUS_OK)
+		if (handler->update(ctx, counterSpan) != CSTATUS_OK)
 		{
 			goto Exit;
 		}
@@ -109,18 +95,15 @@ cstatus_t hkdfExpandProcess(
 		}
 
 		/* tlen becomes the hash size or remaining okm size */
-		tLen = HKDF_MIN(okm->size - okmOffset, SHA256_DIGEST_SIZE);
+		tLen = HKDF_MIN(ncSpanGetSize(okm) - 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;
+		/* write the T buffer back to okm and advance okmOffset by tLen */
+		ncSpanAppend(okm, &okmOffset, t, tLen);
 
 		/* increment counter */
-		counter++;
+		(*counter)++;
 	}
 
 	result = CSTATUS_OK;	/* HMAC operation completed, so set success */
diff --git a/src/hkdf.h b/src/hkdf.h
index 460e203..50ee6e8 100644
--- a/src/hkdf.h
+++ b/src/hkdf.h
@@ -42,20 +42,20 @@
 
 /* typedefs for hdkf callback functions */
 
-typedef cstatus_t (*hmac_hash_func)(void* ctx, const cspan_t* data);
+typedef cstatus_t (*hmac_hash_fn)(void* ctx, 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_hash_fn 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
+	cspan_t info,
+	span_t okm
 );
 
 #endif /* !_NC_HKDF_H */
diff --git a/src/nc-crypto.c b/src/nc-crypto.c
index 97b59cb..56bdf75 100644
--- a/src/nc-crypto.c
+++ b/src/nc-crypto.c
@@ -41,6 +41,7 @@
 *		_IMPL_CRYPTO_SHA256_DIGEST			standard sha256 digest function
 * 		_IMPL_CRYPTO_SHA256_HKDF_EXPAND		hkdf expand function
 * 		_IMPL_CRYPTO_SHA256_HKDF_EXTRACT	hkdf extract function
+*       _IMPL_AES256_CBC_CRYPT				performs an AES 256 CBC encryption/decryption
 * 
 * Macros are used to allow the preprocessor to select the correct implementation
 * or raise errors if no implementation is defined.
@@ -49,6 +50,26 @@
 * calling function, and should return CSTATUS_OK on success, CSTATUS_FAIL on failure.
 */
 
+#define UNREFPARAM(x) (void)(x)
+
+_IMPLSTB cstatus_t _dummyAesFunc(
+	const uint8_t key[32], 
+	const uint8_t iv[16], 
+	const uint8_t* input, 
+	uint8_t* output, 
+	uint32_t dataSize
+)
+{
+	UNREFPARAM(key);
+	UNREFPARAM(iv);
+	UNREFPARAM(input);
+	UNREFPARAM(output);
+	UNREFPARAM(dataSize);
+
+	return CSTATUS_FAIL;
+}
+
+#define _IMPL_AES256_CBC_CRYPT _dummyAesFunc
 
 /*
 * Prioritize embedded builds with mbedtls
@@ -113,7 +134,7 @@
 
 		#define _IMPL_CRYPTO_SHA256_HKDF_EXTRACT		_fallbackHkdfExtract
 
-		_IMPLSTB cstatus_t _fallbackHkdfExtract(const cspan_t* salt, const cspan_t* ikm, sha256_t prk)
+		_IMPLSTB cstatus_t _fallbackHkdfExtract(cspan_t salt, cspan_t ikm, sha256_t prk)
 		{
 			return _IMPL_CRYPTO_SHA256_HMAC(salt, ikm, prk);
 		}
@@ -196,11 +217,11 @@ uint32_t ncCryptoFixedTimeComp(const uint8_t* a, const uint8_t* b, uint32_t size
 	return _IMPL_CRYPTO_FIXED_TIME_COMPARE(a, b, size);
 }
 
-cstatus_t ncCryptoDigestSha256(const cspan_t* data, sha256_t digestOut32)
+cstatus_t ncCryptoDigestSha256(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")
+	DEBUG_ASSERT2(ncSpanIsValidC(data),	"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"
@@ -209,12 +230,12 @@ cstatus_t ncCryptoDigestSha256(const cspan_t* data, sha256_t digestOut32)
 	return _IMPL_CRYPTO_SHA256_DIGEST(data, digestOut32);
 }
 
-cstatus_t ncCryptoHmacSha256(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32)
+cstatus_t ncCryptoHmacSha256(cspan_t key, 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")
+	DEBUG_ASSERT2(ncSpanIsValidC(key),	"Expected key to be non-null")
+	DEBUG_ASSERT2(ncSpanIsValidC(data),	"Expected data to be non-null")
+	DEBUG_ASSERT2(hmacOut32 != NULL,	"Expected hmacOut32 to be non-null")
 
 #ifndef _IMPL_CRYPTO_SHA256_HMAC
 	#error "No SHA256 HMAC implementation defined"
@@ -223,12 +244,12 @@ cstatus_t ncCryptoHmacSha256(const cspan_t* key, const cspan_t* data, sha256_t h
 	return _IMPL_CRYPTO_SHA256_HMAC(key, data, hmacOut32);
 }
 
-cstatus_t ncCryptoSha256HkdfExpand(const cspan_t* prk, const cspan_t* info, span_t* okm)
+cstatus_t ncCryptoSha256HkdfExpand(cspan_t prk, 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")
+	DEBUG_ASSERT2(ncSpanIsValidC(prk),	"Expected prk to be non-null")
+	DEBUG_ASSERT2(ncSpanIsValidC(info),	"Expected info to be non-null")
+	DEBUG_ASSERT2(ncSpanIsValid(okm),	"Expected okm to be non-null")
 
 	/*
 	* RFC 5869: 2.3
@@ -237,7 +258,7 @@ cstatus_t ncCryptoSha256HkdfExpand(const cspan_t* prk, const cspan_t* info, span
 	* important as the counter is 1 byte, so it cannot overflow
 	*/
 
-	if(okm->size > (uint32_t)(0xFFu * SHA256_DIGEST_SIZE))
+	if(okm.size > (uint32_t)(0xFFu * SHA256_DIGEST_SIZE))
 	{
 		return CSTATUS_FAIL;
 	}
@@ -249,12 +270,12 @@ cstatus_t ncCryptoSha256HkdfExpand(const cspan_t* prk, const cspan_t* info, span
 	return _IMPL_CRYPTO_SHA256_HKDF_EXPAND(prk, info, okm);
 }
 
-cstatus_t ncCryptoSha256HkdfExtract(const cspan_t* salt, const cspan_t* ikm, sha256_t prk)
+cstatus_t ncCryptoSha256HkdfExtract(cspan_t salt, 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")
+	DEBUG_ASSERT2(ncSpanIsValidC(salt), "Expected salt to be non-null")
+	DEBUG_ASSERT2(ncSpanIsValidC(ikm),	"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"
@@ -271,10 +292,10 @@ cstatus_t ncCryptoChacha20(
 	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")
+	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"
@@ -282,3 +303,23 @@ cstatus_t ncCryptoChacha20(
 
 	return _IMPL_CHACHA20_CRYPT(key, nonce, input, output, dataSize);
 }
+
+cstatus_t ncAes256CBCEncrypt(
+	const uint8_t key[32],
+	const uint8_t iv[16],
+	const uint8_t* input,
+	uint8_t* output,
+	uint32_t dataSize
+)
+{
+	DEBUG_ASSERT2(key != NULL, "Expected key to be non-null")
+	DEBUG_ASSERT2(iv != NULL, "Expected iv 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_AES256_CBC_CRYPT
+	#error "No AES256 CBC encrypt implementation defined"
+#endif /* !_IMPL_AES256_CBC_CRYPT */
+
+	return _IMPL_AES256_CBC_CRYPT(key, iv, input, output, dataSize);
+}
+\ No newline at end of file
diff --git a/src/nc-crypto.h b/src/nc-crypto.h
index f04ebe0..a1545de 100644
--- a/src/nc-crypto.h
+++ b/src/nc-crypto.h
@@ -29,6 +29,8 @@
 #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 */
+#define AES_IV_SIZE				0x10u		/* CBC IV size matches the AES block size of 128 */
+#define AES_KEY_SIZE			0x20u		/* AES 256 key size */
 
 typedef uint8_t cstatus_t;
 #define CSTATUS_OK				((cstatus_t)0x01u)
@@ -40,13 +42,13 @@ 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 ncCryptoDigestSha256(cspan_t data, sha256_t digestOut32);
 
-cstatus_t ncCryptoHmacSha256(const cspan_t* key, const cspan_t* data, sha256_t hmacOut32);
+cstatus_t ncCryptoHmacSha256(cspan_t key, cspan_t data, sha256_t hmacOut32);
 
-cstatus_t ncCryptoSha256HkdfExpand(const cspan_t* prk, const cspan_t* info, span_t* okm);
+cstatus_t ncCryptoSha256HkdfExpand(cspan_t prk, cspan_t info, span_t okm);
 
-cstatus_t ncCryptoSha256HkdfExtract(const cspan_t* salt, const cspan_t* ikm, sha256_t prk);
+cstatus_t ncCryptoSha256HkdfExtract(cspan_t salt, cspan_t ikm, sha256_t prk);
 
 cstatus_t ncCryptoChacha20(
 	const uint8_t key[CHACHA_KEY_SIZE],
@@ -56,4 +58,12 @@ cstatus_t ncCryptoChacha20(
 	uint32_t dataSize
 );
 
+cstatus_t ncAes256CBCEncrypt(
+	const uint8_t key[32],
+	const uint8_t iv[16],
+	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
index dd319c7..a248578 100644
--- a/src/nc-util.h
+++ b/src/nc-util.h
@@ -68,6 +68,32 @@
 	#define _overflow_check(x)
 #endif
 
+#ifdef NC_EXTREME_COMPAT
+
+	void _nc_memmove(void* dst, const void* src, uint32_t size)
+	{
+		uint32_t i;
+
+		for (i = 0; i < size; i++)
+		{
+			((uint8_t*)dst)[i] = ((uint8_t*)src)[i];
+		}
+	}
+
+	#define MEMMOV _nc_memmove
+
+#else
+
+	/* Include string for memmove */
+	#include <string.h>
+	#define MEMMOV(dst, src, size) memmove(dst, src, size)
+
+#endif /* NC_EXTREME_COMPAT */
+
+#ifndef EMPTY_SPANS
+	#define EMPTY_SPANS 1
+#endif
+
 typedef struct memory_span_struct
 {
 	uint8_t* data;
@@ -80,6 +106,26 @@ typedef struct read_only_memory_span_struct
 	uint32_t size;
 } cspan_t;
 
+static _nc_fn_inline int ncSpanIsValid(span_t span)
+{
+	return span.data != NULL;
+}
+
+static _nc_fn_inline int ncSpanIsValidC(cspan_t span)
+{
+	return span.data != NULL;
+}
+
+static _nc_fn_inline int ncSpanIsValidRange(span_t span, uint32_t offset, uint32_t size)
+{
+	return ncSpanIsValid(span) && offset + size <= span.size;
+}
+
+static _nc_fn_inline int ncSpanIsValidRangeC(cspan_t span, uint32_t offset, uint32_t size)
+{
+	return ncSpanIsValidC(span) && offset + size <= span.size;
+}
+
 static _nc_fn_inline void ncSpanInitC(cspan_t* span, const uint8_t* data, uint32_t size)
 {
 	span->data = data;
@@ -92,4 +138,132 @@ static _nc_fn_inline void ncSpanInit(span_t* span, uint8_t* data, uint32_t size)
 	span->size = size;
 }
 
+static _nc_fn_inline const uint8_t* ncSpanGetOffsetC(cspan_t span, uint32_t offset)
+{
+
+#if EMPTY_SPANS
+	
+	/* 
+	* Allow passing null pointers for empty spans, if enabled, 
+	* otherwise debug guards will catch empty spans
+	*/
+	if (span.size == 0 && offset == 0)
+	{
+		return NULL;
+	}
+
+#endif /* !EMPTY_SPANS */
+
+	DEBUG_ASSERT2(ncSpanIsValidC(span), "Expected span to be non-null");
+	DEBUG_ASSERT2(offset < span.size,	"Expected offset to be less than span size");
+
+	return span.data + offset;
+}
+
+static _nc_fn_inline uint8_t* ncSpanGetOffset(span_t span, uint32_t offset)
+{
+	cspan_t cspan;	
+	ncSpanInitC(&cspan, span.data, span.size);
+	return (uint8_t*)ncSpanGetOffsetC(cspan, offset);
+}
+
+static _nc_fn_inline uint32_t ncSpanGetSizeC(cspan_t span)
+{
+	return ncSpanIsValidC(span) 
+		? span.size
+		: 0;
+}
+
+static _nc_fn_inline uint32_t ncSpanGetSize(span_t span)
+{
+	return ncSpanIsValid(span)
+		? span.size
+		: 0;
+}
+
+static _nc_fn_inline void ncSpanWrite(span_t span, uint32_t offset, const uint8_t* data, uint32_t size)
+{
+	DEBUG_ASSERT2(ncSpanIsValid(span),	"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 */
+	MEMMOV(span.data + offset, data, size);
+}
+
+static _nc_fn_inline void ncSpanAppend(span_t span, uint32_t* offset, const uint8_t* data, uint32_t size)
+{
+	DEBUG_ASSERT2(ncSpanIsValid(span),	"Expected span to be non-null")
+	DEBUG_ASSERT2(offset != NULL,		"Expected offset 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 */
+	MEMMOV(span.data + *offset, data, size);
+
+	/* Increment offset */
+	*offset += size;
+}
+
+static _nc_fn_inline span_t ncSpanSlice(span_t span, uint32_t offset, uint32_t size)
+{
+	span_t slice;
+
+	DEBUG_ASSERT2(ncSpanIsValid(span),	"Expected span to be non-null");
+	DEBUG_ASSERT2(offset + size <= span.size, "Expected offset + size to be less than span size")
+
+	/* Initialize slice, offset input data by the specified offset */
+	ncSpanInit(&slice, span.data + offset, size);
+
+	return slice;
+}
+
+static _nc_fn_inline cspan_t ncSpanSliceC(cspan_t span, uint32_t offset, uint32_t size)
+{
+	cspan_t slice;
+
+	DEBUG_ASSERT2(ncSpanIsValidC(span), "Expected span to be non-null");
+	DEBUG_ASSERT2(offset + size <= span.size, "Expected offset + size to be less than span size")
+
+	/* Initialize slice, offset input data by the specified offset */
+	ncSpanInitC(&slice, span.data + offset, size);
+
+	return slice;
+}
+
+static _nc_fn_inline void ncSpanCopyC(cspan_t src, span_t dest)
+{
+	DEBUG_ASSERT2(ncSpanIsValidC(src), "Expected span to be non-null");
+	DEBUG_ASSERT2(ncSpanIsValid(dest), "Expected offset + size to be less than span size");
+	DEBUG_ASSERT2(dest.size >= src.size, "Output buffer too small. Overrun detected");
+
+	/* Copy data to span */
+	MEMMOV(dest.data, src.data, src.size);
+}
+
+static _nc_fn_inline void ncSpanCopy(span_t src, span_t dest)
+{
+	cspan_t csrc;
+	
+	ncSpanInitC(&csrc, src.data, src.size);
+	ncSpanCopyC(csrc, dest);
+}
+
+static _nc_fn_inline void ncSpanReadC(cspan_t src, uint8_t* dest, uint32_t size)
+{
+	span_t dsts;
+
+	ncSpanInit(&dsts, dest, size);
+	ncSpanCopyC(src, dsts);
+}
+
+static _nc_fn_inline void ncSpanRead(span_t src, uint8_t* dest, uint32_t size)
+{
+	cspan_t srcs;
+
+	ncSpanInitC(&srcs, src.data, src.size);
+	ncSpanReadC(srcs, dest, size);
+}
+
+
 #endif /* !_NC_UTIL_H */
 \ No newline at end of file
diff --git a/src/noscrypt.c b/src/noscrypt.c
index f1aabd4..deadca6 100644
--- a/src/noscrypt.c
+++ b/src/noscrypt.c
@@ -32,10 +32,6 @@
 */
 #define ZERO_FILL(x, size) ncCryptoSecureZero(x, size) 
 
-/* Include string for memmove */
-#include <string.h>
-#define MEMMOV(dst, src, size) memmove(dst, src, size)
-
 /*
 * Validation macros
 */
@@ -44,7 +40,6 @@
 	#define CHECK_INVALID_ARG(x, argPos) if(x == NULL) return NCResultWithArgPosition(E_INVALID_ARG, argPos);
 	#define CHECK_NULL_ARG(x, argPos) if(x == NULL) return NCResultWithArgPosition(E_NULL_PTR, argPos);
 	#define CHECK_ARG_RANGE(x, min, max, argPos) if(x < min || x > max) return NCResultWithArgPosition(E_ARGUMENT_OUT_OF_RANGE, argPos);
-	#define CHECK_CONTEXT_STATE(ctx, argPos) CHECK_INVALID_ARG(ctx->secpCtx, argPos)
 #else
 	/* empty macros */
 	#define CHECK_INVALID_ARG(x)
@@ -52,6 +47,8 @@
 	#define CHECK_ARG_RANGE(x, min, max, argPos) 
 #endif /* !NC_DISABLE_INPUT_VALIDATION */
 
+#define CHECK_CONTEXT_STATE(ctx, argPos) CHECK_INVALID_ARG(ctx->secpCtx, argPos)
+
 /*
 * Actual, private defintion of the NCContext structure 
 * to allow for future development and ABI backords 
@@ -247,7 +244,9 @@ static _nc_fn_inline NCResult _computeConversationKey(
 	ncSpanInitC(&saltSpan, Nip44ConstantSalt, sizeof(Nip44ConstantSalt));
 	ncSpanInitC(&ikmSpan, sharedSecret->value, NC_SHARED_SEC_SIZE);
 	
-	return ncCryptoSha256HkdfExtract(&saltSpan, &ikmSpan, ck->value) == CSTATUS_OK ? NC_SUCCESS : E_OPERATION_FAILED;
+	return ncCryptoSha256HkdfExtract(saltSpan, ikmSpan, ck->value) == CSTATUS_OK 
+		? NC_SUCCESS 
+		: E_OPERATION_FAILED;
 }
 
 
@@ -275,14 +274,13 @@ static cstatus_t _chachaEncipher(const struct nc_expand_keys* keys, NCEncryption
 
 static _nc_fn_inline cstatus_t _getMessageKey(
 	const struct conversation_key* converstationKey, 
-	const cspan_t* nonce,
+	cspan_t nonce,
 	struct message_key* messageKey
 )
 {
 	cspan_t prkSpan;
 	span_t okmSpan;
 
-	DEBUG_ASSERT2(nonce != NULL, "Expected valid nonce buffer")
 	DEBUG_ASSERT2(converstationKey != NULL, "Expected valid conversation key")
 	DEBUG_ASSERT2(messageKey != NULL, "Expected valid message key buffer")
 
@@ -290,10 +288,10 @@ static _nc_fn_inline cstatus_t _getMessageKey(
 	ncSpanInit(&okmSpan, messageKey->value, sizeof(struct message_key));				/* Output produces a message key (write it directly to struct memory) */
 	
 	/* Nonce is the info */
-	return ncCryptoSha256HkdfExpand(&prkSpan, nonce, &okmSpan);
+	return ncCryptoSha256HkdfExpand(prkSpan, nonce, okmSpan);
 }
 
-static _nc_fn_inline NCResult _encryptEx(
+static _nc_fn_inline NCResult _encryptNip44Ex(
 	const NCContext* ctx, 
 	const struct conversation_key* ck, 
 	uint8_t* hmacKey,
@@ -312,10 +310,10 @@ static _nc_fn_inline NCResult _encryptEx(
 
 	result = NC_SUCCESS;
 
-	ncSpanInitC(&nonceSpan, args->nonce32, NC_ENCRYPTION_NONCE_SIZE);
+	ncSpanInitC(&nonceSpan, args->nonceData, NC_ENCRYPTION_NONCE_SIZE);
 	
 	/* Message key will be derrived on every encryption call */
-	if (_getMessageKey(ck, &nonceSpan, &messageKey) != CSTATUS_OK)
+	if (_getMessageKey(ck, nonceSpan, &messageKey) != CSTATUS_OK)
 	{
 		result = E_OPERATION_FAILED;
 		goto Cleanup;
@@ -339,7 +337,7 @@ Cleanup:
 	return result;
 }
 
-static _nc_fn_inline NCResult _decryptEx(const NCContext* ctx, const struct conversation_key* ck, NCEncryptionArgs* args)
+static _nc_fn_inline NCResult _decryptNip44Ex(const NCContext* ctx, const struct conversation_key* ck, NCEncryptionArgs* args)
 {
 	NCResult result;
 	cspan_t nonceSpan;
@@ -352,9 +350,9 @@ static _nc_fn_inline NCResult _decryptEx(const NCContext* ctx, const struct conv
 
 	result = NC_SUCCESS;
 
-	ncSpanInitC(&nonceSpan, args->nonce32, NC_ENCRYPTION_NONCE_SIZE);
+	ncSpanInitC(&nonceSpan, args->nonceData, NC_ENCRYPTION_NONCE_SIZE);
 	
-	if (_getMessageKey(ck, &nonceSpan, &messageKey) != CSTATUS_OK)
+	if (_getMessageKey(ck, nonceSpan, &messageKey) != CSTATUS_OK)
 	{
 		result = E_OPERATION_FAILED;
 		goto Cleanup;
@@ -375,17 +373,16 @@ Cleanup:
 	return result;
 }
 
-static _nc_fn_inline cstatus_t _computeHmac(const uint8_t key[NC_HMAC_KEY_SIZE], const cspan_t* payload, sha256_t hmacOut)
+static _nc_fn_inline cstatus_t _computeHmac(const uint8_t key[NC_HMAC_KEY_SIZE], cspan_t payload, sha256_t hmacOut)
 {
 	cspan_t keySpan;
 
 	DEBUG_ASSERT2(key != NULL,		"Expected valid hmac key")
-	DEBUG_ASSERT2(payload != NULL,	"Expected valid mac verification args")
 	DEBUG_ASSERT2(hmacOut != NULL,	"Expected valid hmac output buffer")
 
 	ncSpanInitC(&keySpan, key, NC_HMAC_KEY_SIZE);
 
-	return ncCryptoHmacSha256(&keySpan, payload, hmacOut);
+	return ncCryptoHmacSha256(keySpan, payload, hmacOut);
 }
 
 static NCResult _verifyMacEx(
@@ -411,7 +408,7 @@ static NCResult _verifyMacEx(
 	* Message key is again required for the hmac verification
 	*/
 
-	if (_getMessageKey((struct conversation_key*)conversationKey, &nonceSpan, &messageKey) != CSTATUS_OK)
+	if (_getMessageKey((struct conversation_key*)conversationKey, nonceSpan, &messageKey) != CSTATUS_OK)
 	{
 		result = E_OPERATION_FAILED;
 		goto Cleanup;
@@ -423,7 +420,7 @@ static NCResult _verifyMacEx(
 	/*
 	* Compute the hmac of the data using the computed hmac key
 	*/
-	if (_computeHmac(keys->hmac_key, &payloadSpan, hmacOut) != CSTATUS_OK)
+	if (_computeHmac(keys->hmac_key, payloadSpan, hmacOut) != CSTATUS_OK)
 	{
 		result = E_OPERATION_FAILED;
 		goto Cleanup;
@@ -442,6 +439,40 @@ Cleanup:
 /*
 * EXTERNAL API FUNCTIONS
 */
+
+
+NC_EXPORT NCResult NC_CC NCResultWithArgPosition(NCResult err, uint8_t argPosition)
+{
+	return -(((NCResult)argPosition << NC_ARG_POSITION_OFFSET) | -err);
+}
+
+NC_EXPORT int NC_CC NCParseErrorCode(NCResult result, uint8_t* argPositionOut)
+{
+	NCResult asPositive;
+	int code;
+
+	/* convert result to a positive value*/
+	asPositive = -result;
+
+	/* Get the error code from the lower 8 bits and the argument position from the upper 8 bits*/
+	code = -(asPositive & NC_ERROR_CODE_MASK);
+
+	/* Allow argument position assignment to be null */
+	if (argPositionOut) 
+	{
+		*argPositionOut = (asPositive >> NC_ARG_POSITION_OFFSET) & 0xFF;
+	}
+
+	return code;
+}
+
+/*	=============================
+*	
+*		Context functions
+* 
+*	============================= 
+*/
+
 NC_EXPORT uint32_t NC_CC NCGetContextStructSize(void) 
 {
 	return sizeof(NCContext);
@@ -499,7 +530,13 @@ NC_EXPORT NCResult NC_CC NCDestroyContext(NCContext* ctx)
 	return NC_SUCCESS;
 }
 
-/* KEY Functions */
+/*	=============================
+*
+*		ECDSA functions
+*
+*	=============================
+*/
+
 NC_EXPORT NCResult NC_CC NCGetPublicKey(
 	const NCContext* ctx, 
 	const NCSecretKey* sk, 
@@ -615,7 +652,7 @@ NC_EXPORT NCResult NC_CC NCSignData(
 	ncSpanInitC(&dataSpan, data, dataSize);
 
 	/* Compute sha256 of the data before signing */
-	if(ncCryptoDigestSha256(&dataSpan, digest) != CSTATUS_OK)
+	if(ncCryptoDigestSha256(dataSpan, digest) != CSTATUS_OK)
 	{
 		return E_INVALID_ARG;
 	}
@@ -646,7 +683,6 @@ NC_EXPORT NCResult NC_CC NCVerifyDigest(
 		return E_INVALID_ARG;
 	}
 
-	/* Verify the signature */
 	result = secp256k1_schnorrsig_verify(ctx->secpCtx, sig64, digest32, 32, &xonly);
 	
 	ZERO_FILL(&xonly, sizeof(xonly));
@@ -674,16 +710,20 @@ NC_EXPORT NCResult NC_CC NCVerifyData(
 	ncSpanInitC(&dataSpan, data, dataSize);
 
 	/* Compute sha256 of the data before verifying */
-	if (ncCryptoDigestSha256(&dataSpan, digest) != CSTATUS_OK)
+	if (ncCryptoDigestSha256(dataSpan, digest) != CSTATUS_OK)
 	{
 		return E_INVALID_ARG;
 	}
 
-	/* Verify the freshly computed digest */
 	return NCVerifyDigest(ctx, pk, digest, sig64);
 }
 
-/* ECDH Functions */
+/*	=============================
+*
+*		ECDH functions
+*
+*	=============================
+*/
 
 NC_EXPORT NCResult NC_CC NCGetSharedSecret(
 	const NCContext* ctx, 
@@ -765,11 +805,28 @@ NC_EXPORT NCResult NC_CC NCEncryptEx(
 	/* Validte ciphertext/plaintext */
 	CHECK_INVALID_ARG(args->inputData, 2)
 	CHECK_INVALID_ARG(args->outputData, 2)
-	CHECK_INVALID_ARG(args->nonce32, 2)
-	CHECK_INVALID_ARG(args->hmacKeyOut32, 2)
+	CHECK_INVALID_ARG(args->nonceData, 2)
+	CHECK_INVALID_ARG(args->keyData, 2)
 	CHECK_ARG_RANGE(args->dataSize, NIP44_MIN_ENC_MESSAGE_SIZE, NIP44_MAX_ENC_MESSAGE_SIZE, 2)	
 
-	return _encryptEx(ctx, (struct conversation_key*)conversationKey, args->hmacKeyOut32, args);
+	switch (args->version) 
+	{
+		/* TODO: Implement nip04 */
+		case NC_ENC_VERSION_NIP04:
+			return E_VERSION_NOT_SUPPORTED;
+
+		case NC_ENC_VERSION_NIP44:
+			return _encryptNip44Ex(
+				ctx, 
+				(struct conversation_key*)conversationKey, 
+				args->keyData, 
+				args
+			);
+
+		default:
+			return E_VERSION_NOT_SUPPORTED;
+	}
+
 }
 
 NC_EXPORT NCResult NC_CC NCEncrypt(
@@ -792,34 +849,42 @@ NC_EXPORT NCResult NC_CC NCEncrypt(
 	/* Validate input/output data */
 	CHECK_INVALID_ARG(args->inputData, 3)
 	CHECK_INVALID_ARG(args->outputData, 3)
-	CHECK_INVALID_ARG(args->nonce32, 3)
-	CHECK_INVALID_ARG(args->hmacKeyOut32, 3)
-	CHECK_ARG_RANGE(args->dataSize, NIP44_MIN_ENC_MESSAGE_SIZE, NIP44_MAX_ENC_MESSAGE_SIZE, 3)
+	CHECK_INVALID_ARG(args->nonceData, 3)
+
+	result = E_OPERATION_FAILED;
 
 	switch(args->version)
 	{		
 		case NC_ENC_VERSION_NIP44:
-			break; /* Allow nip44 */
+		{
+			/* Mac key output is only needed for nip44 */
+			CHECK_INVALID_ARG(args->keyData, 3)
+			CHECK_ARG_RANGE(args->dataSize, NIP44_MIN_ENC_MESSAGE_SIZE, NIP44_MAX_ENC_MESSAGE_SIZE, 3)
+
+			/* Compute the shared point */
+			if ((result = _computeSharedSecret(ctx, sk, pk, &sharedSecret)) != NC_SUCCESS)
+			{
+				goto Cleanup;
+			}
+
+			/* Compute the conversation key from secret and pubkic keys */
+			if ((result = _computeConversationKey(ctx, &sharedSecret, &conversationKey)) != NC_SUCCESS)
+			{
+				goto Cleanup;
+			}
+
+			result = _encryptNip44Ex(ctx, &conversationKey, args->keyData, args);
+		}
+
+		break;
 
 		/* At the moment nip04 compatability is not supported */
 		case NC_ENC_VERSION_NIP04:
 		default:
-			return E_VERSION_NOT_SUPPORTED;
+			result = E_VERSION_NOT_SUPPORTED;
+			break;
 	}
 	
-	/* Compute the shared point */
-	if ((result = _computeSharedSecret(ctx, sk, pk, &sharedSecret)) != NC_SUCCESS)
-	{
-		goto Cleanup;
-	}
-
-	/* Compute the conversation key from secret and pubkic keys */
-	if ((result = _computeConversationKey(ctx, &sharedSecret, &conversationKey)) != NC_SUCCESS)
-	{
-		goto Cleanup;
-	}
-
-	result = _encryptEx(ctx, &conversationKey, args->hmacKeyOut32, args);	
 
 Cleanup:
 	/* Clean up sensitive data */
@@ -830,8 +895,8 @@ Cleanup:
 }
 
 NC_EXPORT NCResult NC_CC NCDecryptEx(
-	const NCContext* ctx, 
-	const uint8_t conversationKey[NC_CONV_KEY_SIZE], 
+	const NCContext* ctx,
+	const uint8_t conversationKey[NC_CONV_KEY_SIZE],
 	NCEncryptionArgs* args
 )
 {
@@ -843,10 +908,18 @@ NC_EXPORT NCResult NC_CC NCDecryptEx(
 	/* Validte ciphertext/plaintext */
 	CHECK_INVALID_ARG(args->inputData, 2)
 	CHECK_INVALID_ARG(args->outputData, 2)
-	CHECK_INVALID_ARG(args->nonce32, 2)
+	CHECK_INVALID_ARG(args->nonceData, 2)
 	CHECK_ARG_RANGE(args->dataSize, NIP44_MIN_ENC_MESSAGE_SIZE, NIP44_MAX_ENC_MESSAGE_SIZE, 2)
 
-	return _decryptEx(ctx, (struct conversation_key*)conversationKey, args);
+	switch (args->version)
+	{
+	case NC_ENC_VERSION_NIP44:
+		return _decryptNip44Ex(ctx, (struct conversation_key*)conversationKey, args);
+
+	case NC_ENC_VERSION_NIP04:
+	default:
+		return E_VERSION_NOT_SUPPORTED;
+	}
 }
 
 NC_EXPORT NCResult NC_CC NCDecrypt(
@@ -869,20 +942,34 @@ NC_EXPORT NCResult NC_CC NCDecrypt(
 	/* Validte ciphertext/plaintext */
 	CHECK_INVALID_ARG(args->inputData, 3)
 	CHECK_INVALID_ARG(args->outputData, 3)
-	CHECK_INVALID_ARG(args->nonce32, 3)
+	CHECK_INVALID_ARG(args->nonceData, 3)
 	CHECK_ARG_RANGE(args->dataSize, NIP44_MIN_ENC_MESSAGE_SIZE, NIP44_MAX_ENC_MESSAGE_SIZE, 3)
 
-	if ((result = _computeSharedSecret(ctx, sk, pk, &sharedSecret)) != NC_SUCCESS)
-	{
-		goto Cleanup;
-	}
+	result = E_OPERATION_FAILED;
 
-	if ((result = _computeConversationKey(ctx, &sharedSecret, &conversationKey)) != NC_SUCCESS)
+	switch (args->version)
 	{
-		goto Cleanup;
+	case NC_ENC_VERSION_NIP44:
+	{
+		if ((result = _computeSharedSecret(ctx, sk, pk, &sharedSecret)) != NC_SUCCESS)
+		{
+			goto Cleanup;
+		}
+
+		if ((result = _computeConversationKey(ctx, &sharedSecret, &conversationKey)) != NC_SUCCESS)
+		{
+			goto Cleanup;
+		}
+
+		result = _decryptNip44Ex(ctx, &conversationKey, args);
 	}
+	break;
 
-	result = _decryptEx(ctx, &conversationKey, args);
+	case NC_ENC_VERSION_NIP04:
+	default:
+		result = E_VERSION_NOT_SUPPORTED;
+		break;
+	}
 
 Cleanup:
 	/* Clean up sensitive data */
@@ -914,7 +1001,7 @@ NC_EXPORT NCResult NCComputeMac(
 	/*
 	* Compute the hmac of the data using the supplied hmac key
 	*/
-	return _computeHmac(hmacKey, &payloadSpan, hmacOut) == CSTATUS_OK ? NC_SUCCESS : E_OPERATION_FAILED;
+	return _computeHmac(hmacKey, payloadSpan, hmacOut) == CSTATUS_OK ? NC_SUCCESS : E_OPERATION_FAILED;
 }
 
 
@@ -978,4 +1065,125 @@ Cleanup:
 	ZERO_FILL(&conversationKey, sizeof(conversationKey));
 
 	return result;
+}
+
+#define ENSURE_ENC_MODE(args, mode) if(args->version != mode) return E_VERSION_NOT_SUPPORTED;
+
+NC_EXPORT NCResult NCSetEncryptionPropertyEx(
+	NCEncryptionArgs* args,
+	uint32_t property,
+	uint8_t* value,
+	uint32_t valueLen
+)
+{
+
+	CHECK_NULL_ARG(args, 0)
+	CHECK_NULL_ARG(value, 2)
+
+	switch (property)
+	{
+	case NC_ENC_SET_VERSION:
+
+		/* Ensure version is proper length */
+		CHECK_ARG_RANGE(valueLen, sizeof(uint32_t), sizeof(uint32_t), 2)
+
+		args->version = *((uint32_t*)value);
+
+		return NC_SUCCESS;
+
+	case NC_ENC_SET_NIP04_IV:
+		/*
+		* The safest way to store the nip04 IV is in the nonce
+		* field. An IV is essentially a nonce. A secure random
+		* number used to encrypt the first block of a CBC chain.
+		*/
+
+		CHECK_ARG_RANGE(valueLen, AES_IV_SIZE, UINT32_MAX, 3)
+
+		ENSURE_ENC_MODE(args, NC_ENC_VERSION_NIP04)
+
+		args->nonceData = value;
+
+		return NC_SUCCESS;
+
+
+	case NC_ENC_SET_NIP04_KEY:
+		/*
+		* The AES key is stored in the hmac key field, since
+		* it won't be used for the operating and should be the same size
+		* as the hmac key.
+		*/
+
+		CHECK_ARG_RANGE(valueLen, AES_KEY_SIZE, UINT32_MAX, 3)
+
+		ENSURE_ENC_MODE(args, NC_ENC_VERSION_NIP04)
+
+		args->keyData = value;
+
+		return NC_SUCCESS;
+
+	case NC_ENC_SET_NIP44_NONCE:
+
+		/* Nonce buffer must be at least the size, max doesnt matter */
+		CHECK_ARG_RANGE(valueLen, NC_ENCRYPTION_NONCE_SIZE, UINT32_MAX, 3)
+
+		/* Nonce is only used in nip44 mode */
+		ENSURE_ENC_MODE(args, NC_ENC_VERSION_NIP44)
+
+		args->nonceData = value;
+
+		return NC_SUCCESS;
+
+	case NC_ENC_SET_NIP44_MAC_KEY:
+
+		/* The maximum size of the buffer doesn't matter as long as its larger than the key size */
+		CHECK_ARG_RANGE(valueLen, NC_HMAC_KEY_SIZE, UINT32_MAX, 3)
+
+		/* Mac key is only used in nip44 mode */
+		ENSURE_ENC_MODE(args, NC_ENC_VERSION_NIP44)
+
+		/*
+		* During encryption the key data buffer is used
+		* to write the hmac hey used for MAC computation
+		* operations.
+		*/
+		args->keyData = value;
+
+		return NC_SUCCESS;
+	}
+
+	return E_INVALID_ARG;
+}
+
+NC_EXPORT NCResult NCSetEncryptionProperty(
+	NCEncryptionArgs* args,
+	uint32_t property,
+	uint32_t value
+)
+{
+	return NCSetEncryptionPropertyEx(
+		args, 
+		property, 
+		(uint8_t*)&value, 
+		sizeof(uint32_t)
+	);
+}
+
+NC_EXPORT NCResult NCSetEncryptionData(
+	NCEncryptionArgs* args,
+	const uint8_t* input,
+	uint8_t* output,
+	uint32_t dataSize
+)
+{
+	CHECK_NULL_ARG(args, 0)
+	CHECK_NULL_ARG(input, 1)
+	CHECK_NULL_ARG(output, 2)
+	CHECK_ARG_RANGE(dataSize, NIP44_MIN_ENC_MESSAGE_SIZE, NIP44_MAX_ENC_MESSAGE_SIZE, 3)
+
+	args->inputData = input;
+	args->outputData = output;
+	args->dataSize = dataSize;
+
+	return NC_SUCCESS;	
 }
 \ No newline at end of file
diff --git a/src/noscryptutil.c b/src/noscryptutil.c
new file mode 100644
index 0000000..4cee2c3
--- /dev/null
+++ b/src/noscryptutil.c
@@ -0,0 +1,910 @@
+/*
+* Copyright (c) 2024 Vaughn Nugent
+*
+* Package: noscrypt
+* File: noscryptutil.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/.
+*/
+
+
+#include <stdlib.h>
+
+#include "nc-util.h"
+#include "nc-crypto.h"
+
+#include <noscryptutil.h>
+
+/*
+* Validation macros
+*/
+
+#ifdef NC_EXTREME_COMPAT
+	#error "Utilities library must be disabled when using extreme compat mode"
+#endif /* NC_EXTREME_COMPAT */
+
+#define MIN_PADDING_SIZE		0x20u
+#define NIP44_VERSION_SIZE		0x01u
+#define NIP44_PT_LEN_SIZE		sizeof(uint16_t)
+
+/*
+* minimum size for a valid nip44 payload
+* 1 byte version + 32 byte nonce + 32 byte mac + 2 byte ptSize + 32bytes minimum length
+*/
+#define NIP44_MIN_PAYLOAD_SIZE  (NIP44_VERSION_SIZE + 0x20 + 0x02 + 0x20 + 0x02)
+
+/*
+* Max payload size is the maximum size of the encrypted message
+* 1 byte version + 32 byte nonce + 32 byte mac + maximum ciphertext size
+*/
+#define NIP44_MAX_PAYLOAD_SIZE (NIP44_VERSION_SIZE + 0x20 + 0x20 + NIP44_MAX_ENC_MESSAGE_SIZE)
+
+/*
+* The minimum ciphertext size is the minimum padded size + the minimum
+* size of the plaintext length field
+*/
+#define NIP44_MIN_CIPHERTEXT_SIZE (MIN_PADDING_SIZE + NIP44_PT_LEN_SIZE)
+
+
+#define _nc_mem_free(x) if(x != NULL) { free(x); x = NULL; }
+#define _nc_mem_alloc(elements, size) calloc(elements, size);
+#define ZERO_FILL ncCryptoSecureZero
+
+#ifndef NC_INPUT_VALIDATION_OFF
+	#define CHECK_INVALID_ARG(x, argPos) if(x == NULL) return NCResultWithArgPosition(E_INVALID_ARG, argPos);
+	#define CHECK_NULL_ARG(x, argPos) if(x == NULL) return NCResultWithArgPosition(E_NULL_PTR, argPos);
+	#define CHECK_ARG_RANGE(x, min, max, argPos) if(x < min || x > max) return NCResultWithArgPosition(E_ARGUMENT_OUT_OF_RANGE, argPos);
+	#define CHECK_ARG_IS(exp, argPos) if(!(exp)) return NCResultWithArgPosition(E_INVALID_ARG, argPos);
+#else
+	/* empty macros */
+	#define CHECK_INVALID_ARG(x)
+	#define CHECK_NULL_ARG(x, argPos) 
+	#define CHECK_ARG_RANGE(x, min, max, argPos) 
+	#define CHECK_ARG_IS(is, expected, argPos)
+#endif /* !NC_DISABLE_INPUT_VALIDATION */
+
+#ifdef _NC_IS_WINDOWS
+	
+	#include <math.h>
+
+	/* performs a log2 on integer types */
+	#define _math_int_log2(x)	(uint32_t)log2((double)x)
+
+#else
+	/* 
+	* GCC/clang does not expose log2 so we can use the __builtin_clz
+	* to find leading zeros of an integer and subtract that from 31 
+	* (bit positions) for int32 
+	*/
+	static _nc_fn_inline uint32_t _math_int_log2(uint32_t val)
+	{
+		DEBUG_ASSERT(val < UINT32_MAX);
+
+		return 31 - __builtin_clz(val);
+	}
+#endif
+
+/* Currently were on nip44 version 2 */
+static const uint8_t Nip44VersionValue[1] = { 0x02u };
+
+struct cipher_buffer_state {
+	
+	cspan_t input;
+	span_t output;
+
+	cspan_t actualOutput;
+};
+
+struct nc_util_enc_struct {
+
+	uint32_t _flags;
+
+	NCEncryptionArgs encArgs;
+
+	struct cipher_buffer_state buffer;
+};
+
+static _nc_fn_inline span_t _ncUtilAllocSpan(uint32_t count, size_t size)
+{
+	span_t span;
+
+#if SIZE_MAX < UINT32_MAX
+
+	if (count > SIZE_MAX)
+	{
+		return span;
+	}
+
+#endif
+
+	span.data = _nc_mem_alloc((size_t)count, size);
+	span.size = (uint32_t)count;
+
+	return span;
+}
+
+static _nc_fn_inline void _ncUtilZeroSpan(span_t span)
+{
+	ZERO_FILL(span.data, span.size);
+}
+
+static _nc_fn_inline void _ncUtilFreeSpan(span_t span)
+{
+	_nc_mem_free(span.data);
+}
+
+static _nc_fn_inline uint32_t _calcNip44PtPadding(uint32_t plaintextSize)
+{
+	uint32_t chunk, nextPower, factor;
+
+	/*
+	* Taken from https://github.com/nostr-protocol/nips/blob/master/44.md
+	*
+	* I believe the idea is to add consisten padding for some better 
+	* disgusing of the plainText data.
+	*/
+
+	if (plaintextSize <= MIN_PADDING_SIZE)
+	{
+		return MIN_PADDING_SIZE;
+	}
+
+	/* Safe to subtract because pt > 0 */
+	nextPower = _math_int_log2(plaintextSize - 1);
+
+	nextPower += 1u;
+
+	nextPower = 1 << nextPower;
+
+	if (nextPower <= 256u)
+	{
+		chunk = 32u;
+	}
+	else 
+	{
+		chunk = nextPower / 8u;
+	}
+	
+	factor = plaintextSize - 1;
+
+	factor /= chunk;
+
+	factor += 1;
+
+	return chunk * factor;
+}
+
+static _nc_fn_inline uint32_t _calcNip44TotalOutSize(uint32_t inputSize)
+{
+	uint32_t bufferSize;
+
+	/*
+	* Buffer size for nip44 is calculated as follows:
+	*   1 byte for the version
+	*   32 bytes for the nonce
+	*   2 bytes for the length of the plainText
+	*   ... padding size
+	*   32 bytes for the MAC
+	*/
+
+	bufferSize = NIP44_VERSION_SIZE;
+
+	bufferSize += NC_ENCRYPTION_NONCE_SIZE;
+
+	bufferSize += NIP44_PT_LEN_SIZE;
+
+	bufferSize += _calcNip44PtPadding(inputSize);
+
+	bufferSize += NC_ENCRYPTION_MAC_SIZE;
+
+	return bufferSize;
+}
+
+static _nc_fn_inline span_t _nip44GetMacData(span_t payload)
+{
+	DEBUG_ASSERT(payload.size > NIP44_VERSION_SIZE + NC_ENCRYPTION_MAC_SIZE);
+
+	/*
+	* The nip44 mac is computed over the nonce+encrypted ciphertext
+	* 
+	* the ciphertext is the entire message buffer, so it includes 
+	* version, nonce, data, padding, and mac space available.
+	* 
+	* This function will return a span that points to the nonce+data 
+	* segment of the buffer for mac computation.
+	* 
+	* The nonce sits directly after the version byte, ct is after,
+	* and the remaining 32 bytes are for the mac. So that means 
+	* macData = ct.size - version.size + mac.size
+	*/
+
+	return ncSpanSlice(
+		payload,
+		NIP44_VERSION_SIZE,
+		payload.size - (NIP44_VERSION_SIZE + NC_ENCRYPTION_MAC_SIZE)
+	);
+}
+
+static _nc_fn_inline span_t _nip44GetMacOutput(span_t payload)
+{
+	DEBUG_ASSERT(payload.size > NC_ENCRYPTION_MAC_SIZE);
+
+	/*
+	* Mac is the final 32 bytes of the ciphertext buffer
+	*/
+	return ncSpanSlice(
+		payload,
+		payload.size - NC_ENCRYPTION_MAC_SIZE,
+		NC_ENCRYPTION_MAC_SIZE
+	);
+}
+
+static _nc_fn_inline int _nip44ParseSegments(
+	cspan_t payload, 
+	cspan_t* nonce,
+	cspan_t* mac,
+	cspan_t* macData,
+	cspan_t* cipherText
+)
+{
+	if (payload.size < NIP44_MIN_PAYLOAD_SIZE)
+	{
+		return 0;
+	}
+
+	/* slice after the version and before the mac segments */
+	*nonce = ncSpanSliceC(
+		payload,
+		NIP44_VERSION_SIZE,
+		NC_ENCRYPTION_NONCE_SIZE
+	);
+
+	/*
+	* Mac is the final 32 bytes of the ciphertext buffer
+	*/
+	*mac = ncSpanSliceC(
+		payload,
+		payload.size - NC_ENCRYPTION_MAC_SIZE,
+		NC_ENCRYPTION_MAC_SIZE
+	);
+
+	/*
+	* The mac data is the nonce+ct segment of the buffer for mac computation.
+	*/
+	*macData = ncSpanSliceC(
+		payload,
+		NIP44_VERSION_SIZE,
+		payload.size - (NIP44_VERSION_SIZE + NC_ENCRYPTION_MAC_SIZE)
+	);
+
+	/*
+	* Ciphertext is after the nonce segment and before the mac segment
+	*/
+	*cipherText = ncSpanSliceC(
+		payload,
+		NIP44_VERSION_SIZE + NC_ENCRYPTION_NONCE_SIZE,
+		payload.size - (NIP44_VERSION_SIZE + NC_ENCRYPTION_NONCE_SIZE + NC_ENCRYPTION_MAC_SIZE)
+	);
+
+	return 1;
+}
+
+
+static _nc_fn_inline void _cipherPublishOutput(NCUtilCipherContext* buffer, uint32_t offset, uint32_t size)
+{
+	span_t slice;
+
+	DEBUG_ASSERT(ncSpanIsValid(buffer->buffer.output));
+
+	if (size == 0)
+	{
+		ncSpanInitC(&buffer->buffer.actualOutput, NULL, 0);
+	}
+	else
+	{
+		/* use slice for debug guards */
+		slice = ncSpanSlice(buffer->buffer.output, offset, size);
+
+		/* init readonly span from mutable */
+		ncSpanInitC(
+			&buffer->buffer.actualOutput, 
+			ncSpanGetOffset(slice, 0), 
+			ncSpanGetSize(slice)
+		);
+	}	
+}
+
+/*
+* I want the encryption/decyption functions to be indempodent
+* meaning all mutations that happen can be repeated without
+* side effects. IE no perminent state changes that can't be
+* undone.
+*/
+
+static NCResult _nip44EncryptCompleteCore(
+	const NCContext* libContext,
+	const NCSecretKey* sk,
+	const NCPublicKey* pk,
+	NCUtilCipherContext* state
+)
+{
+
+	NCResult result;
+	cspan_t plainText;
+	span_t macData, macOutput, message;
+	uint32_t outPos;
+	uint8_t ptSize[NIP44_PT_LEN_SIZE];
+	uint8_t hmacKeyOut[NC_ENCRYPTION_MAC_SIZE];
+	NCEncryptionArgs encArgs;
+
+	outPos = 0;
+	encArgs = state->encArgs;
+	message = state->buffer.output;
+	plainText = state->buffer.input;
+
+	DEBUG_ASSERT(encArgs.version == NC_ENC_VERSION_NIP44);
+
+	ZERO_FILL(hmacKeyOut, sizeof(hmacKeyOut));
+
+	/* Start by appending the version number */
+	ncSpanAppend(message, &outPos, Nip44VersionValue, sizeof(Nip44VersionValue));
+
+	/* next is nonce data */
+	ncSpanAppend(message, &outPos, encArgs.nonceData, NC_ENCRYPTION_NONCE_SIZE);
+	DEBUG_ASSERT(outPos == 1 + NC_ENCRYPTION_NONCE_SIZE);
+
+	/*
+	* Assign the hmac key from the stack buffer. Since the args structure
+	* is copied, it won't leak the address to the stack buffer.
+	*
+	* Should always return success for nip44 because all properties are valid
+	* addresses.
+	*/
+
+	result = NCSetEncryptionPropertyEx(
+		&encArgs,
+		NC_ENC_SET_NIP44_MAC_KEY,
+		hmacKeyOut,
+		sizeof(hmacKeyOut)
+	);
+
+	DEBUG_ASSERT(result == NC_SUCCESS);
+
+	/*
+	* So this is the tricky part. The encryption operation appens directly
+	* on the ciphertext segment
+	*
+	* All current implementations allow overlapping input and output buffers
+	* so we can assign the pt segment on the encryption args
+	*/
+
+	/*
+	* Since the message size and padding bytes will get encrypted,
+	* the buffer should currently point to the start of the encryption segment
+	*
+	* The size of the data to encrypt is the padded size plus the size of the
+	* plainText size field.
+	*/
+
+	result = NCSetEncryptionData(
+		&encArgs,
+		ncSpanGetOffset(message, outPos),	/* in place encryption */
+		ncSpanGetOffset(message, outPos),
+		NIP44_PT_LEN_SIZE + _calcNip44PtPadding(plainText.size) 	/* Plaintext + pt size must be encrypted */
+	);
+
+	DEBUG_ASSERT(result == NC_SUCCESS);
+
+	/* big endian plaintext size */
+	ptSize[0] = (uint8_t)(ncSpanGetSizeC(plainText) >> 8);
+	ptSize[1] = (uint8_t)(ncSpanGetSizeC(plainText) & 0xFF);
+
+	/*
+	* Written position must point to the end of the padded ciphertext
+	* area which the plaintext is written to.
+	*
+	* The plaintext data will be encrypted in place. The encrypted
+	* data is the entired padded region containing the leading byte count
+	* the plaintext data, followed by zero padding.
+	*/
+
+	ncSpanWrite(message, outPos, ptSize, sizeof(ptSize));
+
+	ncSpanWrite(
+		message,
+		outPos + NIP44_PT_LEN_SIZE,		/* write pt directly after length */
+		ncSpanGetOffsetC(plainText, 0),
+		ncSpanGetSizeC(plainText)
+	);
+
+	/* Move position pointer directly after final padding bytes */
+	outPos += encArgs.dataSize;
+
+	result = NCEncrypt(libContext, sk, pk, &encArgs);
+
+	if (result != NC_SUCCESS)
+	{
+		return result;
+	}
+
+	/*
+		MAC is computed over the nonce+encrypted data
+		this helper captures that data segment into a span
+	*/
+
+	macData = _nip44GetMacData(message);
+	macOutput = _nip44GetMacOutput(message);
+
+	result = NCComputeMac(
+		libContext,
+		hmacKeyOut,
+		ncSpanGetOffset(macData, 0),
+		ncSpanGetSize(macData),
+		ncSpanGetOffset(macOutput, 0)
+	);
+
+	if (result != NC_SUCCESS)
+	{
+		return result;
+	}
+
+	outPos += NC_ENCRYPTION_MAC_SIZE;
+
+	DEBUG_ASSERT2(outPos == message.size, "Buffer under/overflow detected");
+
+	/* publish all message bytes to output */
+	_cipherPublishOutput(state, 0, outPos);
+
+	/* zero hmac key before returning */
+	ZERO_FILL(hmacKeyOut, sizeof(hmacKeyOut));
+
+	return NC_SUCCESS;
+}
+
+static NCResult _nip44DecryptCompleteCore(
+	const NCContext* libContext,
+	const NCSecretKey* recvKey,
+	const NCPublicKey* sendKey,
+	NCUtilCipherContext* state
+)
+{
+	NCResult result;
+	NCMacVerifyArgs macArgs;
+	NCEncryptionArgs encArgs;
+	cspan_t macData, macValue, nonce, payload, cipherText;
+	span_t output;
+	uint16_t ptSize;
+
+	DEBUG_ASSERT(libContext && recvKey && sendKey && state);
+	DEBUG_ASSERT(state->encArgs.version == NC_ENC_VERSION_NIP44);
+	DEBUG_ASSERT(ncSpanGetSizeC(state->buffer.input) >= NIP44_MIN_PAYLOAD_SIZE);
+
+	/* ensure decryption mode */
+	DEBUG_ASSERT(state->_flags & NC_UTIL_CIPHER_MODE_DECRYPT);
+
+	/* store local stack copy for safe mutation */
+	encArgs = state->encArgs;
+	payload = state->buffer.input;
+	output = state->buffer.output;
+
+	/*
+	* Copy the input buffer to the output buffer because the 
+	* decryption happens in-place and needs a writable buffer
+	* 
+	* After the operation is complete, we will assign the actual plaintext 
+	* data to the actual output buffer
+	*/
+
+	DEBUG_ASSERT2(ncSpanIsValid(output), "Output buffer was not allocated");
+
+	if (!_nip44ParseSegments(payload, &nonce, &macValue, &macData, &cipherText))
+	{
+		return E_CIPHER_INVALID_FORMAT;
+	}
+
+	/* Verify mac if the user allowed it */
+	if ((state->_flags & NC_UTIL_CIPHER_MAC_NO_VERIFY) == 0)
+	{
+		DEBUG_ASSERT(ncSpanGetSizeC(macValue) == NC_ENCRYPTION_MAC_SIZE);
+		DEBUG_ASSERT(ncSpanGetSizeC(macData) > NC_ENCRYPTION_NONCE_SIZE + MIN_PADDING_SIZE);
+
+		/* Assign the mac data to the mac verify args */
+		macArgs.mac32 = ncSpanGetOffsetC(macValue, 0);
+		macArgs.nonce32 = ncSpanGetOffsetC(nonce, 0);
+		
+		/* message for verifying a mac in nip44 is the nonce+ciphertext */
+		macArgs.payload = ncSpanGetOffsetC(macData, 0);
+		macArgs.payloadSize = ncSpanGetSizeC(macData);
+
+		/* Verify the mac */
+		result = NCVerifyMac(libContext, recvKey, sendKey, &macArgs);
+
+		/* When the mac is invlaid */
+		if (result == E_OPERATION_FAILED)
+		{
+			return E_CIPHER_MAC_INVALID;
+		}
+		/* argument errors */
+		else if (result != NC_SUCCESS)
+		{
+			return result;
+		}
+	}
+
+	/* 
+	* manually assign nonce because it's a constant pointer which
+	* is not allowed when calling setproperty 
+	*/
+	encArgs.nonceData = ncSpanGetOffsetC(nonce, 0);
+
+	DEBUG_ASSERT2(cipherText.size >= MIN_PADDING_SIZE, "Cipertext segment was parsed incorrectly. Too small");
+	
+	result = NCSetEncryptionData(
+		&encArgs,
+		ncSpanGetOffsetC(cipherText, 0),
+		ncSpanGetOffset(output, 0),			/*decrypt ciphertext and write directly to the output buffer */
+		ncSpanGetSizeC(cipherText)
+	);
+
+	DEBUG_ASSERT(result == NC_SUCCESS);
+
+	/*
+	* If decryption was successful, the data should be written 
+	* directly to the output buffer
+	*/
+	result = NCDecrypt(libContext, recvKey, sendKey, &encArgs);
+
+	if (result != NC_SUCCESS)
+	{
+		return result;
+	}
+
+	/*
+	* Parse CT length and assign the output buffer.
+	* 
+	* PT size is stored at the beginning of the ciphertext
+	* segment and is 2 bytes in size, big endian.
+	*/
+
+	ptSize = (uint16_t)(output.data[0] << 8 | output.data[1]);
+
+	/*
+	* If the PT is corrupted or set maliciously, it can overrun
+	* the current buffer. The PT size must be less than the
+	* ciphertext size.
+	*/
+	if (!ncSpanIsValidRange(output, NIP44_PT_LEN_SIZE, ptSize))
+	{
+		return E_OPERATION_FAILED;
+	}
+
+	/*
+	* actual output span should now point to the decrypted plaintext
+	* data segment
+	*/
+	_cipherPublishOutput(state, NIP44_PT_LEN_SIZE, ptSize);
+
+	DEBUG_ASSERT(ncSpanGetSizeC(state->buffer.actualOutput) < cipherText.size);
+
+	return NC_SUCCESS;
+}
+
+NC_EXPORT NCResult NC_CC NCUtilGetEncryptionPaddedSize(uint32_t encVersion, uint32_t plaintextSize)
+{
+	switch (encVersion)
+	{
+	default:
+		return E_VERSION_NOT_SUPPORTED;
+
+	case NC_ENC_VERSION_NIP04:
+		return plaintextSize;
+
+	case NC_ENC_VERSION_NIP44:
+
+		/*
+		* Ensure the plaintext size if a nip44 message does not exceed the maximum size
+		*/
+		CHECK_ARG_IS(plaintextSize - 1 <= NIP44_MAX_ENC_MESSAGE_SIZE, 1);
+
+		return (NCResult)(_calcNip44PtPadding(plaintextSize));
+	}
+}
+
+NC_EXPORT NCResult NC_CC NCUtilGetEncryptionBufferSize(uint32_t encVersion, uint32_t plaintextSize)
+{
+
+	switch (encVersion)
+	{
+	default:
+		return E_VERSION_NOT_SUPPORTED;
+
+		/*
+		* NIP-04 simply uses AES to 1:1 encrypt the plainText
+		* to ciphertext.
+		*/
+	case NC_ENC_VERSION_NIP04:
+		return plaintextSize;
+
+	case NC_ENC_VERSION_NIP44:
+		return (NCResult)(_calcNip44TotalOutSize(plaintextSize));
+	}
+}
+
+
+NC_EXPORT NCUtilCipherContext* NC_CC NCUtilCipherAlloc(uint32_t encVersion, uint32_t flags)
+{
+	NCUtilCipherContext* encCtx;
+
+	/*
+	* Alloc context on heap
+	*/
+	encCtx = (NCUtilCipherContext*)_nc_mem_alloc(1, sizeof(NCUtilCipherContext));
+
+	if (encCtx != NULL)
+	{
+		encCtx->encArgs.version = encVersion;
+		encCtx->_flags = flags;
+	}
+
+	return encCtx;
+}
+
+NC_EXPORT void NC_CC NCUtilCipherFree(NCUtilCipherContext* encCtx)
+{
+	if (!encCtx) 
+	{
+		return;
+	}
+
+	/*
+	* If zero on free flag is set, we can zero all output memory 
+	* before returning the buffer back to the heap
+	*/
+	if ((encCtx->_flags & NC_UTIL_CIPHER_ZERO_ON_FREE) > 0 && ncSpanIsValid(encCtx->buffer.output)) 
+	{
+		_ncUtilZeroSpan(encCtx->buffer.output);
+	}
+
+	/* Free output buffers (null buffers are allowed) */
+	_ncUtilFreeSpan(encCtx->buffer.output);
+
+	/* context can be released */
+	_nc_mem_free(encCtx);
+}
+
+NC_EXPORT NCResult NC_CC NCUtilCipherInit(
+	NCUtilCipherContext* encCtx,
+	const uint8_t* inputData,
+	uint32_t inputSize
+)
+{
+	NCResult outputSize;
+
+	CHECK_NULL_ARG(encCtx, 0);
+	CHECK_NULL_ARG(inputData, 1);
+
+	if ((encCtx->_flags & NC_UTIL_CIPHER_MODE_DECRYPT) > 0)
+	{
+		/*
+		* Validate the input data for proper format for 
+		* the current state version
+		*/
+		switch (encCtx->encArgs.version)
+		{
+		case NC_ENC_VERSION_NIP44:
+		{
+			if (inputSize < NIP44_MIN_PAYLOAD_SIZE)
+			{
+				return E_CIPHER_BAD_INPUT_SIZE;
+			}
+
+			if (inputSize > NIP44_MAX_PAYLOAD_SIZE)
+			{
+				return E_CIPHER_BAD_INPUT_SIZE;
+			}
+
+			/* Ensure the first byte is a valid version */
+			if (inputData[0] != Nip44VersionValue[0])
+			{
+				return E_VERSION_NOT_SUPPORTED;
+			}
+
+			break;
+		}
+		default:
+			return E_VERSION_NOT_SUPPORTED;
+		}
+
+		/*
+		* Alloc a the output buffer to be the same size as the input
+		* data for decryption because the output will always be equal
+		* or smaller than the input data. This is an over-alloc but 
+		* that should be fine
+		*/
+
+		outputSize = inputSize;
+	}
+	else
+	{
+		/*
+		* Calculate the correct output size to store the encryption
+		* data for the given state version
+		*/
+		outputSize = NCUtilGetEncryptionBufferSize(encCtx->encArgs.version, inputSize);
+
+		if (outputSize < 0)
+		{
+			return E_CIPHER_BAD_INPUT_SIZE;
+		}
+	}
+
+	DEBUG_ASSERT(outputSize > 0);
+
+	/*
+	* If the buffer was previously allocated, the reuseable flag
+	* must be set to allow the buffer to be re-used for another
+	* operation.
+	*/
+
+	if (ncSpanIsValid(encCtx->buffer.output))
+	{
+		CHECK_ARG_IS((encCtx->_flags & NC_UTIL_CIPHER_REUSEABLE) > 0, 0);
+
+		/*
+		* if the existing buffer is large enough to hold the new 
+		* data reuse it, otherwise free it and allocate a new buffer
+		*/
+
+		if (outputSize <= encCtx->buffer.output.size)
+		{
+			_ncUtilZeroSpan(encCtx->buffer.output);
+
+			goto AssignInputAndExit;
+		}
+		else
+		{
+			_ncUtilFreeSpan(encCtx->buffer.output);
+		}
+	}
+
+	/* Alloc output buffer within the struct */
+	encCtx->buffer.output = _ncUtilAllocSpan((uint32_t)outputSize, sizeof(uint8_t));
+
+	if (!ncSpanIsValid(encCtx->buffer.output))
+	{
+		return E_OUT_OF_MEMORY;
+	}
+
+AssignInputAndExit:
+
+	/* Confirm output was allocated */
+	DEBUG_ASSERT(ncSpanIsValid(encCtx->buffer.output));
+
+	/* Assign the input data span to point to the assigned input data */
+	ncSpanInitC(&encCtx->buffer.input, inputData, inputSize);
+
+	return NC_SUCCESS;
+}
+
+NC_EXPORT NCResult NC_CC NCUtilCipherGetFlags(const NCUtilCipherContext* ctx)
+{
+	CHECK_NULL_ARG(ctx, 0);
+
+	return (NCResult)(ctx->_flags);
+}
+
+NC_EXPORT NCResult NC_CC NCUtilCipherGetOutputSize(const NCUtilCipherContext* encCtx)
+{
+	CHECK_NULL_ARG(encCtx, 0);
+
+	if (!ncSpanIsValidC(encCtx->buffer.actualOutput))
+	{
+		return E_CIPHER_NO_OUTPUT;
+	}
+
+	return (NCResult)(encCtx->buffer.actualOutput.size);
+}
+
+NC_EXPORT NCResult NC_CC NCUtilCipherReadOutput(
+	const NCUtilCipherContext* encCtx,
+	uint8_t* output,
+	uint32_t outputSize
+)
+{
+	CHECK_NULL_ARG(encCtx, 0);
+	CHECK_NULL_ARG(output, 1);
+
+	if (!ncSpanIsValidC(encCtx->buffer.actualOutput))
+	{
+		return E_CIPHER_NO_OUTPUT;
+	}
+
+	/* Buffer must be as large as the output data  */
+	CHECK_ARG_RANGE(outputSize, encCtx->buffer.actualOutput.size, UINT32_MAX, 2);
+
+	ncSpanReadC(
+		encCtx->buffer.actualOutput,
+		output,
+		outputSize
+	);
+
+	return (NCResult)encCtx->buffer.actualOutput.size;
+}
+
+NC_EXPORT NCResult NCUtilCipherSetProperty(
+	NCUtilCipherContext* ctx,
+	uint32_t property,
+	uint8_t* value,
+	uint32_t valueLen
+)
+{	
+	CHECK_NULL_ARG(ctx, 0)
+
+	/* All other arguments are verified */
+	return NCSetEncryptionPropertyEx(
+		&ctx->encArgs, 
+		property, 
+		value, 
+		valueLen
+	);
+}
+
+NC_EXPORT NCResult NC_CC NCUtilCipherUpdate(
+	NCUtilCipherContext* encCtx,
+	const NCContext* libContext,
+	const NCSecretKey* sk,
+	const NCPublicKey* pk
+)
+{
+	CHECK_NULL_ARG(encCtx, 0);
+	CHECK_NULL_ARG(libContext, 1);
+	CHECK_NULL_ARG(sk, 2);
+	CHECK_NULL_ARG(pk, 3);
+
+	/* Make sure input & output buffers have been assigned/allocated */
+	if (!ncSpanIsValid(encCtx->buffer.output))
+	{
+		return E_INVALID_CONTEXT;
+	}
+	if (!ncSpanIsValidC(encCtx->buffer.input))
+	{
+		return E_INVALID_CONTEXT;
+	}
+
+	/* Reset output data pointer incase it has been moved */
+	_cipherPublishOutput(encCtx, 0, 0);
+
+	switch (encCtx->encArgs.version)
+	{
+	case NC_ENC_VERSION_NIP44:
+
+		if ((encCtx->_flags & NC_UTIL_CIPHER_MODE_DECRYPT) > 0)
+		{
+			return _nip44DecryptCompleteCore(libContext, sk, pk, encCtx);
+		}
+		else
+		{
+			/* Ensure the user manually specified a nonce buffer for encryption mode */
+			if (!encCtx->encArgs.nonceData)
+			{
+				return E_CIPHER_BAD_NONCE;
+			}
+
+			return _nip44EncryptCompleteCore(libContext, sk, pk, encCtx);
+		}
+
+	default:
+		return E_VERSION_NOT_SUPPORTED;
+	}
+}
diff --git a/src/providers/bcrypt.c b/src/providers/bcrypt.c
index d1b9aa5..b9c370b 100644
--- a/src/providers/bcrypt.c
+++ b/src/providers/bcrypt.c
@@ -2,7 +2,7 @@
 * Copyright (c) 2024 Vaughn Nugent
 *
 * Package: noscrypt
-* File: impl/bcrypt.c
+* File: providers/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
@@ -63,7 +63,7 @@ _IMPLSTB NTSTATUS _bcInitSha256(struct _bcrypt_ctx* ctx, DWORD flags)
 	return result;
 }
 
-_IMPLSTB NTSTATUS _bcCreateHmac(struct _bcrypt_ctx* ctx, const cspan_t* key)
+_IMPLSTB NTSTATUS _bcCreateHmac(struct _bcrypt_ctx* ctx, cspan_t key)
 {
 	/*
 	 * NOTE: 
@@ -79,8 +79,8 @@ _IMPLSTB NTSTATUS _bcCreateHmac(struct _bcrypt_ctx* ctx, const cspan_t* key)
 		&ctx->hHash, 
 		NULL, 
 		0, 
-		(uint8_t*)key->data, 
-		key->size, 
+		(uint8_t*)ncSpanGetOffsetC(key, 0), 
+		ncSpanGetSizeC(key),
 		BCRYPT_HASH_REUSABLE_FLAG	/* Enable reusable for expand function */
 	);
 }
@@ -92,7 +92,7 @@ _IMPLSTB NTSTATUS _bcCreate(struct _bcrypt_ctx* ctx)
 	/* Zero out key span for 0 size and NULL data ptr */
 	SecureZeroMemory(&key, sizeof(cspan_t));
 
-	return _bcCreateHmac(ctx, &key);
+	return _bcCreateHmac(ctx, key);
 }
 
 _IMPLSTB NTSTATUS _bcHashDataRaw(const struct _bcrypt_ctx* ctx, const uint8_t* data, uint32_t len)
@@ -100,9 +100,13 @@ _IMPLSTB NTSTATUS _bcHashDataRaw(const struct _bcrypt_ctx* ctx, const uint8_t* d
 	return BCryptHashData(ctx->hHash, (uint8_t*)data, len, 0);
 }
 
-_IMPLSTB NTSTATUS _bcHashData(const struct _bcrypt_ctx* ctx, const cspan_t* data)
+_IMPLSTB NTSTATUS _bcHashData(const struct _bcrypt_ctx* ctx, cspan_t data)
 {
-	return _bcHashDataRaw(ctx, data->data, data->size);
+	return _bcHashDataRaw(
+		ctx, 
+		ncSpanGetOffsetC(data, 0),
+		ncSpanGetSizeC(data)
+	);
 }
 
 _IMPLSTB NTSTATUS _bcFinishHash(const struct _bcrypt_ctx* ctx, sha256_t digestOut32)
@@ -118,8 +122,8 @@ _IMPLSTB void _bcDestroyCtx(struct _bcrypt_ctx* ctx)
 	/* Close the algorithm provider */
 	if (ctx->hAlg) BCryptCloseAlgorithmProvider(ctx->hAlg, 0);
 
-	ctx->hAlg = NULL;
 	ctx->hHash = NULL;
+	ctx->hAlg = NULL;	
 }
 
 #ifndef _IMPL_SECURE_ZERO_MEMSET
@@ -146,7 +150,7 @@ _IMPLSTB void _bcDestroyCtx(struct _bcrypt_ctx* ctx)
 	/* Export function fallack */
 	#define _IMPL_CRYPTO_SHA256_DIGEST			_bcrypt_sha256_digest	
 
-	_IMPLSTB cstatus_t _bcrypt_sha256_digest(const cspan_t* data, sha256_t digestOut32)
+	_IMPLSTB cstatus_t _bcrypt_sha256_digest(cspan_t data, sha256_t digestOut32)
 	{
 		cstatus_t result;
 		struct _bcrypt_ctx ctx;
@@ -177,7 +181,7 @@ _IMPLSTB void _bcDestroyCtx(struct _bcrypt_ctx* ctx)
 	/* 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)
+	_IMPLSTB cstatus_t _bcrypt_hmac_sha256(cspan_t key, cspan_t data, sha256_t hmacOut32)
 	{
 		cstatus_t result;
 		struct _bcrypt_ctx ctx;
@@ -213,7 +217,7 @@ _IMPLSTB void _bcDestroyCtx(struct _bcrypt_ctx* ctx)
 
 	#define _IMPL_CRYPTO_SHA256_HKDF_EXPAND		_bcrypt_fallback_hkdf_expand
 
-	cstatus_t _bcrypt_hkdf_update(void* ctx, const cspan_t* data)
+	static cstatus_t _bcrypt_hkdf_update(void* ctx, cspan_t data)
 	{
 		DEBUG_ASSERT(ctx != NULL)
 
@@ -221,15 +225,16 @@ _IMPLSTB void _bcDestroyCtx(struct _bcrypt_ctx* ctx)
 		return CSTATUS_OK;
 	}
 
-	cstatus_t _bcrypt_hkdf_finish(void* ctx, sha256_t hmacOut32)
+	static cstatus_t _bcrypt_hkdf_finish(void* ctx, sha256_t hmacOut32)
 	{
-		DEBUG_ASSERT(ctx != NULL)
+		DEBUG_ASSERT(ctx != NULL);
+		DEBUG_ASSERT(hmacOut32 != 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)
+	_IMPLSTB cstatus_t _bcrypt_fallback_hkdf_expand(cspan_t prk, cspan_t info, span_t okm)
 	{
 		cstatus_t result;
 		struct _bcrypt_ctx ctx;
diff --git a/src/providers/mbedtls.c b/src/providers/mbedtls.c
index df5201f..ead3279 100644
--- a/src/providers/mbedtls.c
+++ b/src/providers/mbedtls.c
@@ -2,7 +2,7 @@
 * Copyright (c) 2024 Vaughn Nugent
 *
 * Package: noscrypt
-* File: mbedtls.c
+* File: providers/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
@@ -95,13 +95,13 @@ _IMPLSTB const mbedtls_md_info_t* _mbed_sha256_alg(void)
 	
 	#define _IMPL_CRYPTO_SHA256_DIGEST			_mbed_sha256_digest	
 
-	_IMPLSTB cstatus_t _mbed_sha256_digest(const cspan_t* data, sha256_t digestOut32)
+	_IMPLSTB cstatus_t _mbed_sha256_digest(cspan_t data, sha256_t digestOut32)
 	{
-		_overflow_check(data->size)
+		_overflow_check(data.size)
 
 		return mbedtls_sha256(
-			data->data, 
-			data->size, 
+			data.data, 
+			data.size, 
 			digestOut32, 
 			0				/* Set 0 for sha256 mode */
 		) == 0 ? CSTATUS_OK : CSTATUS_FAIL;
@@ -114,19 +114,19 @@ _IMPLSTB const mbedtls_md_info_t* _mbed_sha256_alg(void)
 
 	#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)
+	_IMPLSTB cstatus_t _mbed_sha256_hmac(cspan_t key, cspan_t data, sha256_t hmacOut32)
 	{
-		_overflow_check(data->size)
+		_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")
+		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,
+			key.data, 
+			key.size,
+			data.data, 
+			data.size,
 			hmacOut32
 		) == 0 ? CSTATUS_OK : CSTATUS_FAIL;
 	}
@@ -137,21 +137,21 @@ _IMPLSTB const mbedtls_md_info_t* _mbed_sha256_alg(void)
 
 	#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)
+	_IMPLSTB cstatus_t _mbed_sha256_hkdf_expand(cspan_t prk, 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)
+		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
+			prk.data, 
+			prk.size,
+			info.data, 
+			info.size,
+			okm.data, 
+			okm.size
 		) == 0 ? CSTATUS_OK : CSTATUS_FAIL;
 	}
 
diff --git a/src/providers/monocypher.c b/src/providers/monocypher.c
index 8ffe048..c35f63e 100644
--- a/src/providers/monocypher.c
+++ b/src/providers/monocypher.c
@@ -2,7 +2,7 @@
 * Copyright (c) 2024 Vaughn Nugent
 *
 * Package: noscrypt
-* File: impl/monocypher.c
+* File: providers/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
diff --git a/src/providers/openssl.c b/src/providers/openssl.c
index 1f31796..c2933fb 100644
--- a/src/providers/openssl.c
+++ b/src/providers/openssl.c
@@ -2,7 +2,7 @@
 * Copyright (c) 2024 Vaughn Nugent
 *
 * Package: noscrypt
-* File: impl/openssl.c
+* 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
@@ -26,6 +26,10 @@
 
 #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)
+
 #ifndef _IMPL_SECURE_ZERO_MEMSET
 
 	#define _IMPL_SECURE_ZERO_MEMSET			_ossl_secure_zero_memset
@@ -63,11 +67,20 @@
 
 	#define _IMPL_CRYPTO_SHA256_DIGEST			_ossl_sha256_digest	
 
-	_IMPLSTB cstatus_t _ossl_sha256_digest(const cspan_t* data, sha256_t digestOut32)
+	_IMPLSTB cstatus_t _ossl_sha256_digest(cspan_t data, sha256_t digestOut32)
 	{
-		_overflow_check(data->size)
+		_overflow_check(data.size);
+
+		DEBUG_ASSERT(digestOut32 != NULL);
+		DEBUG_ASSERT(ncSpanIsValidC(data));
 
-		_OSSL_FAIL(SHA256(data->data, data->size, digestOut32))
+		_OSSL_FAIL(
+			SHA256(
+				ncSpanGetOffsetC(data, 0),
+				ncSpanGetSizeC(data),
+				digestOut32
+			)
+		);
 
 		return CSTATUS_OK;
 	}
@@ -81,29 +94,29 @@
 	/* 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)
+	_IMPLSTB cstatus_t _ossl_hmac_sha256(cspan_t key, cspan_t data, sha256_t hmacOut32)
 	{
 		unsigned int hmacLen;
 
-		_overflow_check(key->size)
-		_overflow_check(data->size)
+		_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,
+				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))
+		DEBUG_ASSERT(hmacLen == sizeof(sha256_t));
 
 		return CSTATUS_OK;
 	}
@@ -112,73 +125,144 @@
 
 #ifndef _IMPL_CRYPTO_SHA256_HKDF_EXPAND
 	
-	#include <openssl/hmac.h>
+	#include <openssl/evp.h>
 
 	#define _IMPL_CRYPTO_SHA256_HKDF_EXPAND		_ossl_sha256_hkdf_expand
 
-	cstatus_t _ossl_hkdf_update(void* ctx, const cspan_t* data)
+	struct ossl_hmac_state {
+		EVP_MAC_CTX* libCtx;
+		OSSL_PARAM params[2];
+		cspan_t prk; 
+	};
+
+	static cstatus_t _ossl_hmac_init(const struct ossl_hmac_state* osslCtx)
 	{
-		DEBUG_ASSERT(ctx != NULL)
+		DEBUG_ASSERT(ncSpanIsValidC(osslCtx->prk));
+		DEBUG_ASSERT(osslCtx->params != NULL);
 
-		_overflow_check(data->size)
+		_OSSL_FAIL(
+			EVP_MAC_init(
+				osslCtx->libCtx,
+				ncSpanGetOffsetC(osslCtx->prk, 0),
+				ncSpanGetSizeC(osslCtx->prk),
+				osslCtx->params
+			)
+		);
 
-		_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)
+	static cstatus_t _ossl_hkdf_update(void* ctx, cspan_t data)
 	{
-		unsigned int hmacSize;
+		const struct ossl_hmac_state* osslCtx;
 
-		DEBUG_ASSERT(ctx != NULL)
+		DEBUG_ASSERT(ctx != NULL);
+		_overflow_check(data.size);
 
-		hmacSize = sizeof(sha256_t);
+		osslCtx = (const struct ossl_hmac_state*)ctx;
 
-		_OSSL_FAIL(EVP_DigestFinal_ex((EVP_MD_CTX*)ctx, hmacOut32, &hmacSize))
+		DEBUG_ASSERT(osslCtx->libCtx != NULL);
 
-		/* When configured for sha256, should always be the same size in/out */
-		DEBUG_ASSERT(hmacSize == sizeof(sha256_t))
+		_OSSL_FAIL(
+			EVP_MAC_update(
+				osslCtx->libCtx,
+				ncSpanGetOffsetC(data, 0),
+				ncSpanGetSizeC(data)
+			)
+		);
 		
 		return CSTATUS_OK;
 	}
 
-	_IMPLSTB cstatus_t _ossl_sha256_hkdf_expand(const cspan_t* prk, const cspan_t* info, span_t* okm)
+	static cstatus_t _ossl_hkdf_finish(void* ctx, sha256_t hmacOut32)
 	{
-		EVP_MD_CTX* ctx;
+		const struct ossl_hmac_state* osslCtx;
+		size_t hmacSize;
+
+		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)
+			)
+		);
+
+		/* When configured for sha256, should always be the same size in/out */
+		DEBUG_ASSERT(hmacSize == sizeof(sha256_t));		
+
+		/* 
+		* 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);
+	}
+	
+
+	_IMPLSTB cstatus_t _ossl_sha256_hkdf_expand(cspan_t prk, cspan_t info, span_t okm)
+	{
+		EVP_MAC* mac;
 		cstatus_t result;
-		struct nc_hkdf_fn_cb_struct handler;
+		struct ossl_hmac_state hkdfState;
+		struct nc_hkdf_fn_cb_struct handler;		
 
 		result = CSTATUS_FAIL;
+
+		handler.update = _ossl_hkdf_update;
+		handler.finish = _ossl_hkdf_finish;
 	
+		_overflow_check(prk.size);
+		_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;
+
 		/*
-		* NOTE! Hmac reusable flag must be set to allow for multiple
-		* calls to the finish function without losing the context.
+		* 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 ((ctx = EVP_MD_CTX_create()) == NULL)
+		mac = ossl_mac_fetch_hmac();
+
+		if (mac == NULL)
 		{
-			return CSTATUS_FAIL;
+			goto Cleanup;
 		}
 
-		if (!EVP_DigestInit_ex2(ctx, EVP_sha256(), NULL))
+		hkdfState.libCtx = EVP_MAC_CTX_new(mac);
+
+		if (hkdfState.libCtx == NULL)
 		{
 			goto Cleanup;
 		}
 
-		if (!EVP_DigestUpdate(ctx, prk->data, prk->size)) 
+		if (_ossl_hmac_init(&hkdfState) != CSTATUS_OK)
 		{
 			goto Cleanup;
 		}
-		
-		handler.update = _ossl_hkdf_update;
-		handler.finish = _ossl_hkdf_finish;
 
-		result = hkdfExpandProcess(&handler, ctx, info, okm);
+		DEBUG_ASSERT(EVP_MAC_CTX_get_mac_size(hkdfState.libCtx) == sizeof(sha256_t));
 
-	Cleanup:
+		/* Pass the library  */
+		result = hkdfExpandProcess(&handler, &hkdfState, info, okm);
 
-		EVP_MD_CTX_destroy(ctx);
+	Cleanup:
+		
+		if (hkdfState.libCtx) EVP_MAC_CTX_free(hkdfState.libCtx);
+		if (mac) EVP_MAC_free(mac);
 
 		return result;
 	}
@@ -191,39 +275,130 @@
 
 	#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
+	_IMPLSTB cstatus_t _ossl_cipher_core(
+		const EVP_CIPHER* cipher,
+		cspan_t key,
+		cspan_t iv,
+		cspan_t input,
+		span_t output
 	)
 	{
 		cstatus_t result;
 		EVP_CIPHER_CTX* ctx;
+		int tempLen, osslResult;
+
+		DEBUG_ASSERT2(ncSpanGetSize(output) <= ncSpanGetSizeC(input), "Output buffer must be equal or larger than the input buffer");
+		DEBUG_ASSERT(cipher != NULL);
+
+		DEBUG_ASSERT((uint32_t)EVP_CIPHER_get_key_length(cipher) == ncSpanGetSizeC(key));
+		DEBUG_ASSERT((uint32_t)EVP_CIPHER_iv_length(cipher) == ncSpanGetSizeC(iv));
 
 		result = CSTATUS_FAIL;
 
-		if ((ctx = EVP_CIPHER_CTX_new()) == NULL)
+		ctx = EVP_CIPHER_CTX_new();
+
+		if (ctx == NULL)
 		{
-			return CSTATUS_FAIL;
+			goto Cleanup;
 		}
 
-		if (!EVP_EncryptInit_ex(ctx, EVP_chacha20(), NULL, key, nonce))
+		osslResult = EVP_EncryptInit_ex2(
+			ctx, 
+			cipher, 
+			ncSpanGetOffsetC(key, 0),
+			ncSpanGetOffsetC(iv, 0),
+			NULL
+		);
+
+		if (!osslResult)
 		{
 			goto Cleanup;
 		}
 
-		if (!EVP_EncryptUpdate(ctx, output, (int*)&dataLen, input, dataLen))
+		osslResult = EVP_EncryptUpdate(
+			ctx,
+			ncSpanGetOffset(output, 0),
+			&tempLen,
+			ncSpanGetOffsetC(input, 0),
+			ncSpanGetSizeC(input)
+		);
+
+		if (!osslResult)
 		{
 			goto Cleanup;
 		}
 
+		/*
+		* We can't get a pointer outside the range of the 
+		* output buffer
+		*/
+		if (((uint32_t)tempLen) < ncSpanGetSize(output))
+		{
+			if (!EVP_EncryptFinal_ex(ctx, ncSpanGetOffset(output, tempLen), &tempLen))
+			{
+				goto Cleanup;
+			}
+		}
+
 		result = CSTATUS_OK;
 
 	Cleanup:
 
-		EVP_CIPHER_CTX_free(ctx);
+		if (ctx) EVP_CIPHER_CTX_free(ctx);
+
+		return result;
+	}
+
+	_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* cipher;
+		uint8_t chaChaIv[CHACHA_NONCE_SIZE + 4];
+		cspan_t keySpan, nonceSpan, inputSpan;
+		span_t outputSpan;
+
+		result = CSTATUS_FAIL;
+
+		/*
+		* RFC 7539 ChaCha20 requires a 16 byte initialization vector. A 
+		* counter value is preprended to the nonce to make up the 16 byte 
+		* size.
+		*
+		* The counter is always set to 0 for the nonce.
+		*/
+
+		ncCryptoSecureZero(chaChaIv, sizeof(chaChaIv));
+		MEMMOV(chaChaIv + 4, nonce, CHACHA_NONCE_SIZE);
+
+		ncSpanInitC(&keySpan, key, CHACHA_KEY_SIZE);
+		ncSpanInitC(&nonceSpan, chaChaIv, sizeof(chaChaIv));
+		ncSpanInitC(&inputSpan, input, dataLen);
+		ncSpanInit(&outputSpan, output, dataLen);
+
+		cipher = ossl_evp_fetch_chacha20();
+
+		if (cipher == NULL)
+		{
+			goto Cleanup;
+		}
+
+		result = _ossl_cipher_core(
+			cipher, 
+			keySpan, 
+			nonceSpan, 
+			inputSpan, 
+			outputSpan
+		);
+
+	Cleanup:
+		
+		if (cipher) EVP_CIPHER_free(cipher);
 
 		return result;
 	}
author	vnugent <public@vaughnnugent.com>	2024-08-06 20:56:36 -0400
committer	vnugent <public@vaughnnugent.com>	2024-08-06 20:56:36 -0400
commit	6fdc4bc32ccf653734cccb6e09690cb2973af6d0 (patch)
tree	90ccef1e5edf4d48f36736dfa8c0973bfed106d8 /src
parent	51d0aff9166ddaa3c74dbc2d7c1dcbdefa8405e1 (diff)