1 files changed, 128 insertions, 0 deletions
diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NCUtilCipher.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NCUtilCipher.cs
new file mode 100644
index 0000000..72bb75a
--- /dev/null
+++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NCUtilCipher.cs
@@ -0,0 +1,128 @@
+// Copyright (C) 2024 Vaughn Nugent
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+using System;
+using System.Diagnostics;
+using VNLib.Utils.Cryptography.Noscrypt.@internal;
+
+using NCResult = System.Int64;
+
+namespace VNLib.Utils.Cryptography.Noscrypt.Encryption
+{
+    internal static class NCUtilCipher
+    {
+        /*
+         * This class wraps the low-level cipher functions provided by 
+         * the Noscrypt utility side-car library. 
+         */
+
+        public static nint Alloc(NCContext ctx, uint version, uint flags)
+        {
+            nint cipher = GetTable(ctx).NCUtilCipherAlloc(version, flags);
+
+            if (cipher == nint.Zero)
+            {
+                throw new OutOfMemoryException("Failed to allocate cipher context");
+            }
+
+            //Ensure flags are identical to those set during allocation
+            Debug.Assert(GetFlags(ctx, cipher) == flags);
+
+            return cipher;
+        }
+
+        public static uint GetFlags(NCContext ctx, nint cipher)
+        {
+            NCResult result = GetTable(ctx).NCUtilCipherGetFlags(cipher);
+
+            NCUtil.CheckResult<FunctionTable.NCUtilCipherGetFlagsDelegate>(result, raiseOnFailure: true);
+
+            return (uint)result;
+        }
+
+        public static void Free(NCContext ctx, nint cipher) => GetTable(ctx).NCUtilCipherFree(cipher);
+
+        public static int GetIvSize(NCContext ctx, nint cipher)
+        {
+            NCResult result = GetTable(ctx).NCUtilCipherGetIvSize(cipher);
+
+            NCUtil.CheckResult<FunctionTable.NCUtilCipherGetIvSizeDelegate>(result, raiseOnFailure: true);
+
+            return checked((int)result);
+        }
+
+        public static unsafe void SetProperty(NCContext ctx, nint cipher, uint property, ref readonly byte value, uint valueLen)
+        {
+            fixed (byte* valPtr = &value)
+            {
+                NCResult result = GetTable(ctx).NCUtilCipherSetProperty(cipher, property, valPtr, valueLen);
+
+                NCUtil.CheckResult<FunctionTable.NCUtilCipherSetPropertyDelegate>(result, raiseOnFailure: true);
+            }
+        }
+
+        public static uint GetOutputSize(NCContext ctx, nint cipher)
+        {
+            NCResult result = GetTable(ctx).NCUtilCipherGetOutputSize(cipher);
+
+            NCUtil.CheckResult<FunctionTable.NCUtilCipherGetOutputSizeDelegate>(result, raiseOnFailure: true);
+
+            return (uint)result;
+        }
+
+        public static unsafe uint ReadOutput(NCContext ctx, nint cipher, ref byte outputData, uint outLen)
+        {
+            fixed (byte* outPtr = &outputData)
+            {
+                NCResult result = GetTable(ctx).NCUtilCipherReadOutput(cipher, outPtr, outLen);
+
+                NCUtil.CheckResult<FunctionTable.NCUtilCipherReadOutputDelegate>(result, raiseOnFailure: true);
+
+                return (uint)result;
+            }
+        }
+
+        public static unsafe void InitCipher(NCContext ctx, nint cipher, byte* inputPtr, uint inputSize)
+        {
+            NCResult result = GetTable(ctx).NCUtilCipherInit(cipher, inputPtr, inputSize);
+
+            NCUtil.CheckResult<FunctionTable.NCUtilCipherInitDelegate>(result, raiseOnFailure: true);
+        }
+
+        public static unsafe void Update(
+            NCContext ctx,
+            nint cipher,
+            ref readonly NCSecretKey localKey,
+            ref readonly NCPublicKey remoteKey
+        )
+        {
+            fixed (NCSecretKey* sk = &localKey)
+            fixed (NCPublicKey* pk = &remoteKey)
+            {
+                NCResult result = GetTable(ctx).NCUtilCipherUpdate(
+                    cipher: cipher,
+                    libContext: ctx.DangerousGetHandle(),
+                    secKey: sk,
+                    pubKey: pk
+                );
+
+                NCUtil.CheckResult<FunctionTable.NCUtilCipherInitDelegate>(result, raiseOnFailure: true);
+            }
+        }
+
+        private static ref readonly FunctionTable GetTable(NCContext ctx) => ref ctx.Library.Functions;
+    }
+
+}