diff options
Diffstat (limited to 'wrappers')
19 files changed, 897 insertions, 732 deletions
diff --git a/wrappers/dotnet/Taskfile.yaml b/wrappers/dotnet/Taskfile.yaml deleted file mode 100644 index 9690e07..0000000 --- a/wrappers/dotnet/Taskfile.yaml +++ /dev/null @@ -1,60 +0,0 @@ -#Builds c# libraries for produc - -version: '3' - -vars: - INT_DIR: '{{.SCRATCH_DIR}}/obj/{{.MODULE_NAME}}/' - MS_ARGS: '/p:RunAnalyzersDuringBuild=false /p:IntermediateOutputPath="{{.INT_DIR}}" /p:UseCommonOutputDirectory=true /p:BuildInParallel=true /p:MultiProcessorCompilation=true /p:ErrorOnDuplicatePublishOutputFiles=false' - PACK_OUT: '{{.OUTPUT_DIR}}/{{.HEAD_SHA}}/pkg' - -tasks: - -#called by build pipeline to build module - build: - dir: '{{.USER_WORKING_DIR}}' - cmds: - - echo "building module {{.MODULE_NAME}}" - - #build debug mode first - - task: build_debug - - task: build_release - - publish: - dir: '{{.USER_WORKING_DIR}}' - cmds: - - #push packages to the sleet feed (feed path is vnbuild global) - - sleet push "{{.PACK_OUT}}/debug/" --source debug --config "{{.SLEET_CONFIG_PATH}}" --force - - sleet push "{{.PACK_OUT}}/release/" --source release --config "{{.SLEET_CONFIG_PATH}}" --force - -#called by build pipeline to clean module - clean: - dir: '{{.USER_WORKING_DIR}}' - cmds: - #clean solution - - dotnet clean /p:BuildInParallel=true /p:MultiProcessorCompilation=true - - for: [ obj/, bin/ ] - cmd: powershell rm -Recurse -Force "{{.ITEM}}" - -#Build tasks that use the solution file to build the module - build_debug: - dir: '{{.USER_WORKING_DIR}}' - internal: true - cmds: - - cd {{.MODULE_DIR}} && dotnet publish -c debug {{.MS_ARGS}} - - cd {{.MODULE_DIR}} && dotnet pack -c debug {{.MS_ARGS}} -o "{{.PACK_OUT}}/debug/" - - build_release: - dir: '{{.USER_WORKING_DIR}}' - internal: true - cmds: - - cd {{.MODULE_DIR}} && dotnet publish -c release {{.MS_ARGS}} - - cd {{.MODULE_DIR}} && dotnet pack -c release {{.MS_ARGS}} -o "{{.PACK_OUT}}/release/" - - - packsource: - dir: '{{.USER_WORKING_DIR}}' - internal: true - cmds: - #copy source code to target - - powershell -Command "Get-ChildItem -Include *.cs,*.csproj -Recurse | Where { \$_.FullName -notlike '*\obj\*' -and \$_.FullName -notlike '*\bin\*' } | Resolve-Path -Relative | tar --files-from - -czf '{{.TARGET}}/src.tgz'"
\ No newline at end of file diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/.runsettings b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/.runsettings new file mode 100644 index 0000000..bbc95aa --- /dev/null +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/.runsettings @@ -0,0 +1,8 @@ +<?xml version="1.0" encoding="utf-8"?> +<RunSettings> + <RunConfiguration> + <EnvironmentVariables> + <NOSCRYPT_DLL_PATH>../../../../../../../build/windows/debug/noscrypt.dll</NOSCRYPT_DLL_PATH> + </EnvironmentVariables> + </RunConfiguration> +</RunSettings>
\ No newline at end of file diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/README.md b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/README.md new file mode 100644 index 0000000..34f68bf --- /dev/null +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/README.md @@ -0,0 +1,4 @@ + +# VNLib.Utils.Cryptography.Noscrypt + +_A dotnet C# warpper library for noscrypt which is part of the VNLib collection of libraries_
\ No newline at end of file diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/Taskfile.yaml b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/Taskfile.yaml new file mode 100644 index 0000000..dfb739f --- /dev/null +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/Taskfile.yaml @@ -0,0 +1,81 @@ +#Builds c# libraries for produc + +version: '3' + +vars: + TARGET_FRAMEWORK: '{{ .TARGET_FRAMEWORK | default "net8.0" }}' + +tasks: + +#called by build pipeline to build module + build: + dir: '{{ .USER_WORKING_DIR }}' + vars: + PACK_OUT: '{{ .OUTPUT_DIR }}/{{ .HEAD_SHA }}/pkg' + MS_ARGS: + /p:RunAnalyzersDuringBuild=false + /p:UseCommonOutputDirectory=true + /p:BuildInParallel=true + /p:MultiProcessorCompilation=true + /p:ErrorOnDuplicatePublishOutputFiles=false + cmds: + - cmd: echo "building project {{ .PROJECT_NAME }}" + silent: true + + #updates the project versions for all inlcuded .NET projects + - cmd: dotnet-gitversion.exe /updateprojectfiles + + - cmd: dotnet publish -c debug {{ .MS_ARGS }} + - cmd: dotnet publish -c release {{ .MS_ARGS }} + + #create nuget packages and write them directly to the output directory + - cmd: dotnet pack {{ .MS_ARGS }} -c debug -o "{{ .PACK_OUT }}/debug/" + - cmd: dotnet pack {{ .MS_ARGS }} -c release -o "{{ .PACK_OUT }}/release/" + + postbuild_success: + deps: + - task: pack_source + - task: pack_artifacts + vars: { CONFIG: 'debug' } + - task: pack_artifacts + vars: { CONFIG: 'release' } + + cmds: + - cmd: echo 'artifacts packaged' + silent: true + + pack_artifacts: + dir: '{{ .USER_WORKING_DIR }}' + internal: true + vars: + SOURCE: 'bin/{{ .CONFIG }}/{{ .TARGET_FRAMEWORK }}/publish' + TARGET: '{{ .USER_WORKING_DIR }}/bin/{{ .CONFIG }}.tgz' + cmds: + - cmd: cd {{ .SOURCE }} && tar -czf '{{ lower .TARGET }}' . + + pack_source: + dir: '{{ .USER_WORKING_DIR }}' + internal: true + vars: + TARGET: '{{ .USER_WORKING_DIR }}/bin' + INCLUDES: + src + tests + README.md + Taskfile.yaml + EXCLUDES: + --exclude='*obj/' + --exclude='*bin/' + cmds: + #copy source code to target + - cmd: cd .. && tar {{ .EXCLUDES }} -czf '{{ .TARGET }}/src.tgz' {{ .INCLUDES }} + +#called by build pipeline to clean module + clean: + dir: '{{ .USER_WORKING_DIR }}' + cmds: + #clean solution + - dotnet clean /p:BuildInParallel=true /p:MultiProcessorCompilation=true + - for: [ obj/, bin/ ] + cmd: '{{ if eq OS "windows" }}powershell rm -Recurse -Force{{ else }}rm -rf{{ end }} "{{ .ITEM }}"' + diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NCUtilCipher.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NCCipherUtil.cs index 72bb75a..5dc2a94 100644 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NCUtilCipher.cs +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NCCipherUtil.cs @@ -15,20 +15,24 @@ using System; using System.Diagnostics; +using System.Runtime.InteropServices; + using VNLib.Utils.Cryptography.Noscrypt.@internal; +using static VNLib.Utils.Cryptography.Noscrypt.NoscryptLibrary; + using NCResult = System.Int64; namespace VNLib.Utils.Cryptography.Noscrypt.Encryption { - internal static class NCUtilCipher + public unsafe static class NCCipherUtil { /* * 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) + internal static nint Alloc(NCContext ctx, uint version, uint flags) { nint cipher = GetTable(ctx).NCUtilCipherAlloc(version, flags); @@ -43,7 +47,7 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption return cipher; } - public static uint GetFlags(NCContext ctx, nint cipher) + internal static uint GetFlags(NCContext ctx, nint cipher) { NCResult result = GetTable(ctx).NCUtilCipherGetFlags(cipher); @@ -52,9 +56,9 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption return (uint)result; } - public static void Free(NCContext ctx, nint cipher) => GetTable(ctx).NCUtilCipherFree(cipher); + internal static void Free(NCContext ctx, nint cipher) => GetTable(ctx).NCUtilCipherFree(cipher); - public static int GetIvSize(NCContext ctx, nint cipher) + internal static int GetIvSize(NCContext ctx, nint cipher) { NCResult result = GetTable(ctx).NCUtilCipherGetIvSize(cipher); @@ -63,7 +67,7 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption return checked((int)result); } - public static unsafe void SetProperty(NCContext ctx, nint cipher, uint property, ref readonly byte value, uint valueLen) + internal static void SetProperty(NCContext ctx, nint cipher, uint property, ref readonly byte value, uint valueLen) { fixed (byte* valPtr = &value) { @@ -73,7 +77,7 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption } } - public static uint GetOutputSize(NCContext ctx, nint cipher) + internal static uint GetOutputSize(NCContext ctx, nint cipher) { NCResult result = GetTable(ctx).NCUtilCipherGetOutputSize(cipher); @@ -82,7 +86,7 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption return (uint)result; } - public static unsafe uint ReadOutput(NCContext ctx, nint cipher, ref byte outputData, uint outLen) + internal static uint ReadOutput(NCContext ctx, nint cipher, ref byte outputData, uint outLen) { fixed (byte* outPtr = &outputData) { @@ -94,14 +98,14 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption } } - public static unsafe void InitCipher(NCContext ctx, nint cipher, byte* inputPtr, uint inputSize) + internal static 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( + internal static void Update( NCContext ctx, nint cipher, ref readonly NCSecretKey localKey, @@ -122,7 +126,46 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption } } - private static ref readonly FunctionTable GetTable(NCContext ctx) => ref ctx.Library.Functions; + +#if DEBUG + /* + * Conversation key is not meant to be a public api. Callers + * should use Encrypt/Decrypt methods to handle encryption. + * + * This method exists for vector testing purposes only. + */ + public static void GetConverstationKey( + NCContext ctx, + ref readonly NCSecretKey localKey, + ref readonly NCPublicKey remoteKey, + Span<byte> conversationKeyOut32 + ) + { + ArgumentNullException.ThrowIfNull(ctx); + ArgumentOutOfRangeException.ThrowIfNotEqual( + conversationKeyOut32.Length, + NC_CONVERSATION_KEY_SIZE, + nameof(conversationKeyOut32) + ); + + fixed (NCSecretKey* sk = &localKey) + fixed (NCPublicKey* pk = &remoteKey) + fixed(byte* convKey32Ptr = &MemoryMarshal.GetReference(conversationKeyOut32)) + { + NCResult result = GetTable(ctx).NCGetConversationKey( + ctx: ctx.DangerousGetHandle(), + sk, + pk, + convKey32Ptr + ); + + NCUtil.CheckResult<FunctionTable.NCUtilCipherInitDelegate>(result, raiseOnFailure: true); + } + } +#endif + + private static ref readonly FunctionTable GetTable(NCContext ctx) + => ref ctx.Library.Functions; } } diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NoscryptCipher.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NoscryptMessageCipher.cs index b30ea44..e44addf 100644 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NoscryptCipher.cs +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Encryption/NoscryptMessageCipher.cs @@ -18,6 +18,8 @@ using System.Threading; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; +using Microsoft.Win32.SafeHandles; + using VNLib.Utils.Memory; using VNLib.Utils.Cryptography.Noscrypt.Random; using static VNLib.Utils.Cryptography.Noscrypt.NoscryptLibrary; @@ -27,29 +29,54 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption /// <summary> /// The noscrypt util cipher wapper /// </summary> - /// <param name="ctx"></param> - /// <param name="flags">Cipher creation flags</param> + /// <param name="ctx">A reference to the library context object</param> + /// <param name="cipher">A pointer to an existing cipher context that this instance owns</param> /// <param name="version">The cipher specification version</param> - public sealed class NoscryptCipher(NCContext ctx, NoscryptCipherVersion version, NoscryptCipherFlags flags) : VnDisposeable + public class NoscryptMessageCipher : SafeHandleMinusOneIsInvalid { + private readonly NCContext _context; + private readonly NoscryptCipherVersion _version; private IMemoryHandle<byte>? _ivBuffer; - private readonly nint _cipher = NCUtilCipher.Alloc(ctx, (uint)version, (uint)flags); + + private NoscryptMessageCipher(NCContext ctx, nint cipher, NoscryptCipherVersion version) + : base(ownsHandle: true) + { + SetHandle(cipher); + _context = ctx; + _version = version; + } + + /// <summary> + /// Allocates and initializes a new cipher instance using the specified + /// </summary> + /// <param name="context">A reference to the noscrypt library context</param> + /// <param name="version">The encryption standard to use</param> + /// <param name="flags">The raw cipher flags to the pass to the cipher initialization function</param> + /// <returns>A new <see cref="NoscryptMessageCipher"/> instance</returns> + public static NoscryptMessageCipher Create(NCContext context, NoscryptCipherVersion version, NoscryptCipherFlags flags) + { + return new( + context, + NCCipherUtil.Alloc(context, (uint)version, (uint)flags), + version + ); + } /// <summary> /// The cipher standard version used by this instance /// </summary> - public NoscryptCipherVersion Version => version; + public NoscryptCipherVersion Version => _version; /// <summary> /// Gets the flags set for the cipher instance /// </summary> - public uint GetFlags() => NCUtilCipher.GetFlags(ctx, _cipher); + public uint GetFlags() => NCCipherUtil.GetFlags(_context, handle); /// <summary> /// Gets the cipher's initilaization vector size (or nonce) /// </summary> /// <returns>The size of the IV in bytes</returns> - public int GetIvSize() => NCUtilCipher.GetIvSize(ctx, _cipher); + public int GetIvSize() => NCCipherUtil.GetIvSize(_context, handle); /// <summary> /// Gets the internal heap buffer that holds the cipher's initalization @@ -121,9 +148,9 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption fixed (byte* inputPtr = &inputData) { - NCUtilCipher.InitCipher(ctx, _cipher, inputPtr, inputSize); + NCCipherUtil.InitCipher(_context, handle, inputPtr, inputSize); - NCUtilCipher.Update(ctx, _cipher, in localKey, in remoteKey); + NCCipherUtil.Update(_context, handle, in localKey, in remoteKey); } } @@ -153,7 +180,7 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption /// Gets the size of the output buffer required to read the cipher output /// </summary> /// <returns>The size of the output in bytes</returns> - public int GetOutputSize() => checked((int)NCUtilCipher.GetOutputSize(ctx, _cipher)); + public int GetOutputSize() => checked((int)NCCipherUtil.GetOutputSize(_context, handle)); /// <summary> /// Reads the output data from the cipher into the specified buffer @@ -166,7 +193,7 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption { ArgumentOutOfRangeException.ThrowIfLessThan(size, GetOutputSize()); - return checked((int)NCUtilCipher.ReadOutput(ctx, _cipher, ref outputData, (uint)size)); + return checked((int)NCCipherUtil.ReadOutput(_context, handle, ref outputData, (uint)size)); } /// <summary> @@ -186,7 +213,7 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption private IMemoryHandle<byte> AllocIvBuffer() { //Use the context heap to allocate the internal iv buffer - MemoryHandle<byte> buffer = MemoryUtil.SafeAlloc<byte>(ctx.Heap, GetIvSize(), zero: true); + MemoryHandle<byte> buffer = MemoryUtil.SafeAlloc<byte>(_context.Heap, GetIvSize(), zero: true); try { @@ -199,9 +226,9 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption * buffer is required so we don't need to pin managed memory * nor worry about the GC moving the buffer. */ - NCUtilCipher.SetProperty( - ctx, - _cipher, + NCCipherUtil.SetProperty( + _context, + DangerousGetHandle(), NC_ENC_SET_IV, ref buffer.GetReference(), (uint)buffer.Length @@ -217,10 +244,12 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Encryption } ///<inheritdoc/> - protected override void Free() + protected override bool ReleaseHandle() { - NCUtilCipher.Free(ctx, _cipher); + NCCipherUtil.Free(_context, handle); _ivBuffer?.Dispose(); + + return true; } } diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/INostrCrypto.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/INostrCrypto.cs deleted file mode 100644 index 9b4d36c..0000000 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/INostrCrypto.cs +++ /dev/null @@ -1,88 +0,0 @@ -// 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 VNLib.Utils.Cryptography.Noscrypt.Encryption; - -namespace VNLib.Utils.Cryptography.Noscrypt -{ - public interface INostrCrypto - { - - /// <summary> - /// Gets a nostr public key from a secret key. - /// </summary> - /// <param name="secretKey">A reference to the secret key to get the public key from</param> - /// <param name="publicKey">A reference to the public key structure to write the recovered key to</param> - /// <exception cref="ArgumentException"></exception> - /// <exception cref="ArgumentNullException"></exception> - void GetPublicKey(ref readonly NCSecretKey secretKey, ref NCPublicKey publicKey); - - /// <summary> - /// Validates a secret key is in a valid format. - /// </summary> - /// <param name="secretKey">A readonly reference to key structure to validate</param> - /// <returns>True if the key is consiered valid against the secp256k1 curve</returns> - /// <exception cref="ArgumentException"></exception> - /// <exception cref="ArgumentNullException"></exception> - bool ValidateSecretKey(ref readonly NCSecretKey secretKey); - - /// <summary> - /// Allocates a new cipher instance with the supplied options. - /// </summary> - /// <param name="version">The cipher specification version</param> - /// <param name="flags">The cipher initialziation flags</param> - /// <returns>The cipher instance</returns> - NoscryptCipher AllocCipher(NoscryptCipherVersion version, NoscryptCipherFlags flags); - - /// <summary> - /// Signs the supplied data with the secret key and random32 nonce, then writes - /// the message signature to the supplied sig64 buffer. - /// </summary> - /// <param name="secretKey">The secret key used to sign the message</param> - /// <param name="random32">A highly secure random nonce used to seed the signature</param> - /// <param name="data">A pointer to the first byte in the message to sign</param> - /// <param name="dataSize">The size of the message in bytes</param> - /// <param name="sig64">A pointer to the first byte of a 64 byte buffer used to write the message signature to</param> - /// <exception cref="ArgumentException"></exception> - /// <exception cref="ArgumentNullException"></exception> - void SignData( - ref readonly NCSecretKey secretKey, - ref readonly byte random32, - ref readonly byte data, - uint dataSize, - ref byte sig64 - ); - - /// <summary> - /// Performs cryptographic verification of the supplied data - /// against the supplied public key. - /// </summary> - /// <param name="pubKey">The signer's public key</param> - /// <param name="data">A pointer to the first byte in the message to sign</param> - /// <param name="dataSize">The number of bytes in the message</param> - /// <param name="sig64">A pointer to the signature buffer</param> - /// <returns>True if the signature could be verified against the public key. False otherwise</returns> - /// <exception cref="ArgumentException"></exception> - /// <exception cref="ArgumentNullException"></exception> - bool VerifyData( - ref readonly NCPublicKey pubKey, - ref readonly byte data, - uint dataSize, - ref readonly byte sig64 - ); - } -} diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NCUtil.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NCKeyUtil.cs index 307bbc1..50e1c9a 100644 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NCUtil.cs +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NCKeyUtil.cs @@ -14,18 +14,21 @@ // along with this program. If not, see <https://www.gnu.org/licenses/>. using System; -using System.Reflection; -using System.Runtime.CompilerServices; using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using VNLib.Utils.Extensions; +using VNLib.Utils.Cryptography.Noscrypt.@internal; using static VNLib.Utils.Cryptography.Noscrypt.NoscryptLibrary; using NCResult = System.Int64; namespace VNLib.Utils.Cryptography.Noscrypt { - - public static class NCUtil + /// <summary> + /// Contains utility methods for working with nostr keys + /// </summary> + public static unsafe class NCKeyUtil { /// <summary> /// Gets a span of bytes from the current secret key @@ -115,79 +118,68 @@ namespace VNLib.Utils.Cryptography.Noscrypt return ref Unsafe.As<byte, NCPublicKey>(ref asBytes); } - internal static void CheckResult<T>(NCResult result, bool raiseOnFailure) where T : Delegate + /// <summary> + /// Gets a nostr public key from a secret key. + /// </summary> + /// <param name="secretKey">A reference to the secret key to get the public key from</param> + /// <param name="publicKey">A reference to the public key structure to write the recovered key to</param> + /// <exception cref="ArgumentException"></exception> + /// <exception cref="ArgumentNullException"></exception> + public static void GetPublicKey( + NCContext context, + ref readonly NCSecretKey secretKey, + ref NCPublicKey publicKey + ) { - //Only negative values are errors - if (result >= NC_SUCCESS) - { - return; - } - - NCResult asPositive = -result; + Check(context); - // Error code are only 8 bits, if an argument error occured, the - // argument number will be in the next upper 8 bits - NCErrorCodes errorCode = (NCErrorCodes)(asPositive & 0xFF); - byte argNumber = (byte)((asPositive >> 8) & 0xFF); - - switch (errorCode) + fixed (NCSecretKey* pSecKey = &secretKey) + fixed (NCPublicKey* pPubKey = &publicKey) { - case NCErrorCodes.E_NULL_PTR: - RaiseNullArgExceptionForArgumentNumber<T>(argNumber); - break; - case NCErrorCodes.E_INVALID_ARG: - RaiseArgExceptionForArgumentNumber<T>(argNumber); - break; - case NCErrorCodes.E_ARGUMENT_OUT_OF_RANGE: - RaiseOORExceptionForArgumentNumber<T>(argNumber); - break; - case NCErrorCodes.E_INVALID_CTX: - throw new InvalidOperationException("The library context object is null or invalid"); - case NCErrorCodes.E_OPERATION_FAILED: - RaiseOperationFailedException(raiseOnFailure); - break; - case NCErrorCodes.E_VERSION_NOT_SUPPORTED: - throw new NotSupportedException("The requested version is not supported"); - - default: - if(raiseOnFailure) - { - throw new InvalidOperationException($"The operation failed with error, code: {errorCode} for arugment {argNumber:x}"); - } - break; + NCResult result = GetTable(context).NCGetPublicKey( + context.DangerousGetHandle(), + pSecKey, + pPubKey + ); + + NCUtil.CheckResult<FunctionTable.NCGetPublicKeyDelegate>(result, raiseOnFailure: true); } } - private static void RaiseOperationFailedException(bool raise) + /// <summary> + /// Validates a secret key is in a valid format. + /// </summary> + /// <param name="secretKey">A readonly reference to key structure to validate</param> + /// <returns>True if the key is consiered valid against the secp256k1 curve</returns> + /// <exception cref="ArgumentException"></exception> + /// <exception cref="ArgumentNullException"></exception> + public static bool ValidateSecretKey( + NCContext context, + ref readonly NCSecretKey secretKey + ) { - if (raise) + Check(context); + + fixed (NCSecretKey* pSecKey = &secretKey) { - throw new InvalidOperationException("The operation failed for an unknown reason"); - } - } + NCResult result = GetTable(context).NCValidateSecretKey( + context.DangerousGetHandle(), + pSecKey + ); - private static void RaiseNullArgExceptionForArgumentNumber<T>(int argNumber) where T : Delegate - { - //Get delegate parameters - Type type = typeof(T); - ParameterInfo arg = type.GetMethod("Invoke")!.GetParameters()[argNumber]; - throw new ArgumentNullException(arg.Name, "Argument is null or invalid cannot continue"); - } + NCUtil.CheckResult<FunctionTable.NCValidateSecretKeyDelegate>(result, raiseOnFailure: false); - private static void RaiseArgExceptionForArgumentNumber<T>(int argNumber) where T : Delegate - { - //Get delegate parameters - Type type = typeof(T); - ParameterInfo arg = type.GetMethod("Invoke")!.GetParameters()[argNumber]; - throw new ArgumentException("Argument is null or invalid cannot continue", arg.Name); + return result == NC_SUCCESS; + } } - private static void RaiseOORExceptionForArgumentNumber<T>(int argNumber) where T : Delegate + private static void Check(NCContext? context) { - //Get delegate parameters - Type type = typeof(T); - ParameterInfo arg = type.GetMethod("Invoke")!.GetParameters()[argNumber]; - throw new ArgumentOutOfRangeException(arg.Name, "Argument is out of range of acceptable values"); + ArgumentNullException.ThrowIfNull(context); + context.ThrowIfClosed(); } + + private static ref readonly FunctionTable GetTable(NCContext ctx) + => ref ctx.Library.Functions; } } diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NoscryptExtensions.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NoscryptExtensions.cs deleted file mode 100644 index e96ff96..0000000 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NoscryptExtensions.cs +++ /dev/null @@ -1,75 +0,0 @@ -// 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.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -using static VNLib.Utils.Cryptography.Noscrypt.NoscryptLibrary; - -namespace VNLib.Utils.Cryptography.Noscrypt -{ - - public static class NoscryptExtensions - { - public static void SignData( - this INostrCrypto lib, - ref readonly NCSecretKey secKey, - ReadOnlySpan<byte> random32, - ReadOnlySpan<byte> data, - Span<byte> signatureBuffer - ) - { - ArgumentOutOfRangeException.ThrowIfLessThan(signatureBuffer.Length, NC_SIGNATURE_SIZE, nameof(signatureBuffer)); - ArgumentOutOfRangeException.ThrowIfLessThan(random32.Length, 32, nameof(random32)); - ArgumentOutOfRangeException.ThrowIfZero(data.Length, nameof(data)); - - lib.SignData( - secretKey: in secKey, - random32: in MemoryMarshal.GetReference(random32), - data: in MemoryMarshal.GetReference(data), - dataSize: (uint)data.Length, - sig64: ref MemoryMarshal.GetReference(signatureBuffer) - ); - } - -#if DEBUG - /* - * Conversation key is not meant to be a public api. Callers - * should use Encrypt/Decrypt methods to handle encryption. - * - * This method exists for vector testing purposes only. - */ - public static void GetConverstationKey( - this NostrCrypto lib, - ref readonly NCSecretKey secretKey, - ref readonly NCPublicKey publicKey, - Span<byte> conversationKeyOut32 - ) - { - ArgumentNullException.ThrowIfNull(lib); - ArgumentOutOfRangeException.ThrowIfNotEqual(conversationKeyOut32.Length, NC_CONVERSATION_KEY_SIZE, nameof(conversationKeyOut32)); - - //Get the conversation key - lib.GetConverstationKey( - secretKey: in secretKey, - publicKey: in publicKey, - key32: ref MemoryMarshal.GetReference(conversationKeyOut32) - ); - - } -#endif - } -} diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NoscryptLibrary.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NoscryptLibrary.cs index 35c6a49..2df63eb 100644 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NoscryptLibrary.cs +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NoscryptLibrary.cs @@ -37,6 +37,7 @@ namespace VNLib.Utils.Cryptography.Noscrypt public unsafe sealed class NoscryptLibrary(SafeLibraryHandle Library, bool OwnsHandle) : VnDisposeable { public const string NoscryptDefaultLibraryName = "noscrypt"; + public const string NoscryptDllPathEnvName = "NOSCRYPT_DLL_PATH"; //Constant values match the noscrypt.h header public const int NC_SEC_KEY_SIZE = 0x20; @@ -172,33 +173,16 @@ namespace VNLib.Utils.Cryptography.Noscrypt } /// <summary> - /// Initializes a new NostrCrypto context wraper directly that owns the internal context. - /// This may be done once at app startup and is thread-safe for the rest of the - /// application lifetime. - /// </summary> - /// <param name="heap">The heap to allocate the context from</param> - /// <param name="entropy32">The random entropy data to initialize the context with</param> - /// <returns>The library wrapper handle</returns> - public NostrCrypto InitializeCrypto(IUnmangedHeap heap, ReadOnlySpan<byte> entropy32) - { - ArgumentNullException.ThrowIfNull(heap); - - //Create the crypto interface from the new context object - return new NostrCrypto( - context: Initialize(heap, entropy32), - ownsContext: true - ); - } - - /// <summary> - /// Initializes a new NostrCrypto context wraper directly that owns the internal context. - /// This may be done once at app startup and is thread-safe for the rest of the - /// application lifetime. + /// Initialize a new NCContext for use. This may be done once at app startup + /// and is thread-safe for the rest of the application lifetime. /// </summary> - /// <param name="heap">The heap to allocate the context from</param> - /// <param name="random">Random source used to generate context entropy</param> - /// <returns>The library wrapper handle</returns> - public NostrCrypto InitializeCrypto(IUnmangedHeap heap, IRandomSource random) + /// <param name="heap"></param> + /// <param name="enropy32">The 32byte random seed/nonce for the noscrypt context</param> + /// <returns>The inialized context</returns> + /// <exception cref="OutOfMemoryException"></exception> + /// <exception cref="ArgumentNullException"></exception> + /// <exception cref="ArgumentOutOfRangeException"></exception> + public NCContext Initialize(IUnmangedHeap heap, IRandomSource random) { ArgumentNullException.ThrowIfNull(random); @@ -206,13 +190,9 @@ namespace VNLib.Utils.Cryptography.Noscrypt Span<byte> entropy = stackalloc byte[NC_CTX_ENTROPY_SIZE]; random.GetRandomBytes(entropy); - NostrCrypto nc = InitializeCrypto(heap, entropy); - - MemoryUtil.InitializeBlock(entropy); - - return nc; + return Initialize(heap, entropy); } - + ///<inheritdoc/> protected override void Free() { @@ -256,6 +236,16 @@ namespace VNLib.Utils.Cryptography.Noscrypt /// </summary> /// <returns>The loaded library instance</returns> /// <exception cref="DllNotFoundException"></exception> - public static NoscryptLibrary LoadDefault() => Load(NoscryptDefaultLibraryName, DllImportSearchPath.SafeDirectories); + public static NoscryptLibrary LoadDefault() + { + string? libPath = Environment.GetEnvironmentVariable(NoscryptDllPathEnvName); + libPath ??= NoscryptDefaultLibraryName; + + Console.WriteLine("Loading library {0}", libPath); + + libPath = libPath.Replace("\"", ""); + + return Load(libPath); + } } } diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NostrCrypto.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NostrCrypto.cs deleted file mode 100644 index 1e833d2..0000000 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NostrCrypto.cs +++ /dev/null @@ -1,167 +0,0 @@ -// 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.Runtime.CompilerServices; -using System.Diagnostics.CodeAnalysis; - -using VNLib.Utils.Cryptography.Noscrypt.@internal; -using VNLib.Utils.Cryptography.Noscrypt.Encryption; -using static VNLib.Utils.Cryptography.Noscrypt.NoscryptLibrary; - -using NCResult = System.Int64; - -namespace VNLib.Utils.Cryptography.Noscrypt -{ - /// <summary> - /// A default implementation of the <see cref="INostrCrypto"/> interface - /// </summary> - /// <param name="context">The initialized library context</param> - public unsafe class NostrCrypto(NCContext context, bool ownsContext) : VnDisposeable, INostrCrypto - { - /// <summary> - /// Gets the underlying library context. - /// </summary> - public NCContext Context => context; - - private ref readonly FunctionTable Functions => ref context.Library.Functions; - - ///<inheritdoc/> - public NoscryptCipher AllocCipher(NoscryptCipherVersion version, NoscryptCipherFlags flags) => new (context, version, flags); - - ///<inheritdoc/> - public void GetPublicKey(ref readonly NCSecretKey secretKey, ref NCPublicKey publicKey) - { - Check(); - - fixed (NCSecretKey* pSecKey = &secretKey) - fixed (NCPublicKey* pPubKey = &publicKey) - { - NCResult result = Functions.NCGetPublicKey.Invoke(context.DangerousGetHandle(), pSecKey, pPubKey); - NCUtil.CheckResult<FunctionTable.NCGetPublicKeyDelegate>(result, true); - } - } - - ///<inheritdoc/> - public void SignData( - ref readonly NCSecretKey secretKey, - ref readonly byte random32, - ref readonly byte data, - uint dataSize, - ref byte sig64 - ) - { - Check(); - - fixed (NCSecretKey* pSecKey = &secretKey) - fixed (byte* pData = &data, pSig = &sig64, pRandom = &random32) - { - NCResult result = Functions.NCSignData.Invoke( - ctx: context.DangerousGetHandle(), - sk: pSecKey, - random32: pRandom, - data: pData, - dataSize, - sig64: pSig - ); - - NCUtil.CheckResult<FunctionTable.NCSignDataDelegate>(result, true); - } - } - - ///<inheritdoc/> - public bool ValidateSecretKey(ref readonly NCSecretKey secretKey) - { - Check(); - - IntPtr libCtx = context.DangerousGetHandle(); - - fixed (NCSecretKey* pSecKey = &secretKey) - { - /* - * Validate should return a result of 1 if the secret key is valid - * or a 0 if it is not. - */ - NCResult result = Functions.NCValidateSecretKey.Invoke(libCtx, pSecKey); - NCUtil.CheckResult<FunctionTable.NCValidateSecretKeyDelegate>(result, false); - - return result == NC_SUCCESS; - } - } - - ///<inheritdoc/> - public bool VerifyData( - ref readonly NCPublicKey pubKey, - ref readonly byte data, - uint dataSize, - ref readonly byte sig64 - ) - { - Check(); - - fixed(NCPublicKey* pPubKey = &pubKey) - fixed (byte* pData = &data, pSig = &sig64) - { - NCResult result = Functions.NCVerifyData.Invoke(context.DangerousGetHandle(), pPubKey, pData, dataSize, pSig); - NCUtil.CheckResult<FunctionTable.NCVerifyDataDelegate>(result, false); - - return result == NC_SUCCESS; - } - } - -#if DEBUG - - /// <summary> - /// DEBUG ONLY: Gets the conversation key for the supplied secret key and public key - /// </summary> - /// <param name="secretKey">The sender's private key</param> - /// <param name="publicKey">The receiver's public key</param> - /// <param name="key32">A pointer to the 32byte buffer to write the conversation key to</param> - public void GetConverstationKey( - ref readonly NCSecretKey secretKey, - ref readonly NCPublicKey publicKey, - ref byte key32 - ) - { - Check(); - - fixed (NCSecretKey* pSecKey = &secretKey) - fixed (NCPublicKey* pPubKey = &publicKey) - fixed (byte* pKey = &key32) - { - NCResult result = Functions.NCGetConversationKey.Invoke(context.DangerousGetHandle(), pSecKey, pPubKey, pKey); - NCUtil.CheckResult<FunctionTable.NCGetConversationKeyDelegate>(result, true); - } - } - -#endif - ///<inheritdoc/> - protected override void Free() - { - if(ownsContext) - { - context.Dispose(); - } - } - - private static void ThrowIfNullRef([DoesNotReturnIf(false)] ref readonly byte value, string name) - { - if(Unsafe.IsNullRef(in value)) - { - throw new ArgumentNullException(name); - } - } - } -} diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Singatures/NCSignatureUtil.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Singatures/NCSignatureUtil.cs new file mode 100644 index 0000000..2755ceb --- /dev/null +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Singatures/NCSignatureUtil.cs @@ -0,0 +1,175 @@ +// 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.Runtime.InteropServices; + +using VNLib.Utils.Extensions; +using VNLib.Utils.Cryptography.Noscrypt.@internal; +using static VNLib.Utils.Cryptography.Noscrypt.NoscryptLibrary; + +using NCResult = System.Int64; + +namespace VNLib.Utils.Cryptography.Noscrypt.Singatures +{ + + /// <summary> + /// Contains utility methods for signing and verifying data using the noscrypt library + /// </summary> + public unsafe static class NCSignatureUtil + { + /// <summary> + /// Signs the data using the supplied secret key and + /// entropy pointer + /// </summary> + /// <param name="context">The initialized context memory to pass to the library</param> + /// <param name="secretKey">A reference to a structure containing the private key data</param> + /// <param name="random32">A pointer to a 32 byte buffer containing high entropy random data</param> + /// <param name="data">A pointer to a buffer containing the data to sign</param> + /// <param name="dataSize">The size of the data buffer in bytes</param> + /// <param name="sig64">A pointer to a 64 byte buffer to write signature data to</param> + /// <exception cref="InvalidOperationException"></exception> + public static void SignData( + NCContext context, + ref readonly NCSecretKey secretKey, + ref readonly byte random32, + ref readonly byte data, + uint dataSize, + ref byte sig64 + ) + { + Check(context); + + fixed (NCSecretKey* pSecKey = &secretKey) + fixed (byte* pData = &data, pSig = &sig64, pRandom = &random32) + { + NCResult result = GetTable(context).NCSignData( + ctx: context.DangerousGetHandle(), + sk: pSecKey, + random32: pRandom, + data: pData, + dataSize, + sig64: pSig + ); + + NCUtil.CheckResult<FunctionTable.NCSignDataDelegate>(result, raiseOnFailure: true); + } + } + + /// <summary> + /// Verifies signed data against the supplied public key + /// </summary> + /// <param name="context">The initialized context memory to pass to the library</param> + /// <param name="publicKey">A reference to a structure containing the public key data</param> + /// <param name="data">A pointer to a buffer containing the data to verify</param> + /// <param name="dataSize">The size of the data buffer in bytes</param> + /// <param name="sig64">A pointer to a 64 byte buffer to read signature data from</param> + /// <returns>True if the signature was signed by the supplied public key, false otherwise</returns> + public static bool VerifyData( + NCContext context, + ref readonly NCPublicKey publicKey, + ref readonly byte data, + uint dataSize, + ref readonly byte sig64 + ) + { + Check(context); + + fixed (NCPublicKey* pPubKey = &publicKey) + fixed (byte* pData = &data, pSig = &sig64) + { + NCResult result = GetTable(context).NCVerifyData( + context.DangerousGetHandle(), + pk: pPubKey, + data: pData, + dataSize, + sig64: pSig + ); + + NCUtil.CheckResult<FunctionTable.NCVerifyDataDelegate>(result, false); + + return result == NC_SUCCESS; + } + } + + /// <summary> + /// Signs the data using the supplied secret key and + /// entropy pointer + /// </summary> + /// <param name="context">The initialized context memory to pass to the library</param> + /// <param name="secretKey">A reference to a structure containing the private key data</param> + /// <param name="random32">A pointer to a 32 byte buffer containing high entropy random data</param> + /// <param name="data">A pointer to a buffer containing the data to sign</param> + /// <param name="signatureBuffer">A pointer to a 64 byte buffer to write signature data to</param> + /// <exception cref="InvalidOperationException"></exception> + public static void SignData( + NCContext context, + ref readonly NCSecretKey secretKey, + ReadOnlySpan<byte> random32, + ReadOnlySpan<byte> data, + Span<byte> signatureBuffer + ) + { + ArgumentOutOfRangeException.ThrowIfLessThan(signatureBuffer.Length, NC_SIGNATURE_SIZE, nameof(signatureBuffer)); + ArgumentOutOfRangeException.ThrowIfLessThan(random32.Length, 32, nameof(random32)); + ArgumentOutOfRangeException.ThrowIfZero(data.Length, nameof(data)); + + SignData( + context, + secretKey: in secretKey, + random32: in MemoryMarshal.GetReference(random32), + data: in MemoryMarshal.GetReference(data), + dataSize: (uint)data.Length, + sig64: ref MemoryMarshal.GetReference(signatureBuffer) + ); + } + + /// <summary> + /// Verifies signed data against the supplied public key + /// </summary> + /// <param name="context">The initialized context memory to pass to the library</param> + /// <param name="publicKey">A reference to a structure containing the public key data</param> + /// <param name="data">A pointer to a buffer containing the data to verify</param> + /// <param name="signatureBuffer">A pointer to a 64 byte buffer to read signature data from</param> + /// <returns>True if the signature was signed by the supplied public key, false otherwise</returns> + public static bool VerifyData( + NCContext context, + ref readonly NCPublicKey publicKey, + ReadOnlySpan<byte> data, + ReadOnlySpan<byte> signatureBuffer + ) + { + ArgumentOutOfRangeException.ThrowIfLessThan(signatureBuffer.Length, NC_SIGNATURE_SIZE, nameof(signatureBuffer)); + ArgumentOutOfRangeException.ThrowIfZero(data.Length, nameof(data)); + + return VerifyData( + context, + publicKey: in publicKey, + data: in MemoryMarshal.GetReference(data), + dataSize: (uint)data.Length, + sig64: ref MemoryMarshal.GetReference(signatureBuffer) + ); + } + + private static void Check(NCContext? context) + { + ArgumentNullException.ThrowIfNull(context); + context.ThrowIfClosed(); + } + + private static ref readonly FunctionTable GetTable(NCContext ctx) + => ref ctx.Library.Functions; + } +} diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NoscryptSigner.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Singatures/NoscryptSigner.cs index c81790b..063d2c0 100644 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/NoscryptSigner.cs +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/Singatures/NoscryptSigner.cs @@ -14,21 +14,23 @@ // along with this program. If not, see <https://www.gnu.org/licenses/>. using System; -using VNLib.Utils.Cryptography.Noscrypt.Random; -using VNLib.Utils.Extensions; -using VNLib.Utils.Memory; +using VNLib.Utils.Memory; +using VNLib.Utils.Extensions; +using VNLib.Utils.Cryptography.Noscrypt; +using VNLib.Utils.Cryptography.Noscrypt.Random; using static VNLib.Utils.Cryptography.Noscrypt.NoscryptLibrary; -namespace VNLib.Utils.Cryptography.Noscrypt +namespace VNLib.Utils.Cryptography.Noscrypt.Singatures { + /// <summary> /// A simple wrapper class to sign nostr message data using /// the noscrypt library /// </summary> /// <param name="noscrypt">The noscrypt library instance</param> /// <param name="random">A random entropy pool used to source random data for signature entropy</param> - public class NoscryptSigner(INostrCrypto noscrypt, IRandomSource random) + public class NoscryptSigner(NCContext context, IRandomSource random) { /// <summary> /// Gets the size of the buffer required to hold the signature @@ -72,12 +74,16 @@ namespace VNLib.Utils.Cryptography.Noscrypt /// <exception cref="ArgumentException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> public string SignData( - ReadOnlySpan<byte> secretKey, - ReadOnlySpan<byte> message, + ReadOnlySpan<byte> secretKey, + ReadOnlySpan<byte> message, INostrSignatureEncoder? format = null ) { - return SignData(in NCUtil.AsSecretKey(secretKey), message, format); + return SignData( + in NCKeyUtil.AsSecretKey(secretKey), + message, + format + ); } /// <summary> @@ -90,8 +96,8 @@ namespace VNLib.Utils.Cryptography.Noscrypt /// <exception cref="ArgumentException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> public string SignData( - ref readonly NCSecretKey secretkey, - ReadOnlySpan<byte> message, + ref readonly NCSecretKey secretkey, + ReadOnlySpan<byte> message, INostrSignatureEncoder? format = null ) { @@ -115,8 +121,8 @@ namespace VNLib.Utils.Cryptography.Noscrypt /// <exception cref="ArgumentException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> public void SignData( - ref readonly NCSecretKey secretkey, - ReadOnlySpan<byte> data, + ref readonly NCSecretKey secretkey, + ReadOnlySpan<byte> data, Span<byte> signature ) { @@ -126,7 +132,35 @@ namespace VNLib.Utils.Cryptography.Noscrypt Span<byte> entropy = stackalloc byte[NC_SIG_ENTROPY_SIZE]; random.GetRandomBytes(entropy); - noscrypt.SignData(in secretkey, entropy, data, signature); + NCSignatureUtil.SignData( + context, + in secretkey, + entropy, + data, + signature + ); + } + + public bool VerifyData( + ReadOnlySpan<byte> publicKey, + ReadOnlySpan<byte> data, + ReadOnlySpan<byte> sig + ) + { + return VerifyData( + in NCKeyUtil.AsPublicKey(publicKey), + data, + sig + ); + } + + public bool VerifyData( + ref readonly NCPublicKey pk, + ReadOnlySpan<byte> data, + ReadOnlySpan<byte> sig + ) + { + return NCSignatureUtil.VerifyData(context, in pk, data, sig); } } diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/VNLib.Utils.Cryptography.Noscrypt.csproj b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/VNLib.Utils.Cryptography.Noscrypt.csproj index 4d1868c..29a4b8f 100644 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/VNLib.Utils.Cryptography.Noscrypt.csproj +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/VNLib.Utils.Cryptography.Noscrypt.csproj @@ -1,5 +1,5 @@ <Project Sdk="Microsoft.NET.Sdk"> - + <PropertyGroup> <TargetFramework>net8.0</TargetFramework> <Nullable>enable</Nullable> @@ -9,7 +9,7 @@ <RootNamespace>VNLib.Utils.Cryptography.Noscrypt</RootNamespace> <AssemblyName>VNLib.Utils.Cryptography.Noscrypt</AssemblyName> </PropertyGroup> - + <PropertyGroup> <Authors>Vaughn Nugent</Authors> <Company>Vaughn Nugent</Company> @@ -19,10 +19,22 @@ <PackageProjectUrl>https://www.vaughnnugent.com/resources/software/modules/Noscrypt</PackageProjectUrl> <RepositoryUrl>https://github.com/VnUgE/noscryot/tree/master/dotnet/VNLib.Utils.Cryptography.Noscrypt</RepositoryUrl> </PropertyGroup> - + <ItemGroup> - <PackageReference Include="VNLib.Hashing.Portable" Version="0.1.0-ci0124" /> - <PackageReference Include="VNLib.Utils" Version="0.1.0-ci0124" /> + <None Include="..\README.md"> + <Pack>True</Pack> + <PackagePath>\</PackagePath> + </None> + <None Include="..\..\..\..\LICENSE"> + <Pack>True</Pack> + <PackagePath>\</PackagePath> + <CopyToOutputDirectory>Always</CopyToOutputDirectory> + </None> </ItemGroup> - + + <ItemGroup> + <PackageReference Include="VNLib.Hashing.Portable" Version="0.1.0-ci0202" /> + <PackageReference Include="VNLib.Utils" Version="0.1.0-ci0202" /> + </ItemGroup> + </Project> diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/internal/FunctionTable.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/internal/FunctionTable.cs index 0cda5e2..269ae4d 100644 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/internal/FunctionTable.cs +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/internal/FunctionTable.cs @@ -119,7 +119,7 @@ namespace VNLib.Utils.Cryptography.Noscrypt.@internal internal delegate NCResult NCSignDataDelegate(IntPtr ctx, NCSecretKey* sk, byte* random32, byte* data, uint dataSize, byte* sig64); [SafeMethodName("NCVerifyData")] - internal delegate NCResult NCVerifyDataDelegate(IntPtr ctx, NCPublicKey* sk, byte* data, uint dataSize, byte* sig64); + internal delegate NCResult NCVerifyDataDelegate(IntPtr ctx, NCPublicKey* pk, byte* data, uint dataSize, byte* sig64); [SafeMethodName("NCGetConversationKey")] internal delegate NCResult NCGetConversationKeyDelegate(IntPtr ctx, NCSecretKey* sk, NCPublicKey* pk, byte* keyOut32); diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/internal/NCUtil.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/internal/NCUtil.cs new file mode 100644 index 0000000..16f46c6 --- /dev/null +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/src/internal/NCUtil.cs @@ -0,0 +1,104 @@ +// 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.Reflection; +using static VNLib.Utils.Cryptography.Noscrypt.NoscryptLibrary; + +using NCResult = System.Int64; + +namespace VNLib.Utils.Cryptography.Noscrypt.@internal +{ + + public static class NCUtil + { + + + internal static void CheckResult<T>(NCResult result, bool raiseOnFailure) where T : Delegate + { + //Only negative values are errors + if (result >= NC_SUCCESS) + { + return; + } + + NCResult asPositive = -result; + + // Error code are only 8 bits, if an argument error occured, the + // argument number will be in the next upper 8 bits + NCErrorCodes errorCode = (NCErrorCodes)(asPositive & 0xFF); + byte argNumber = (byte)(asPositive >> 8 & 0xFF); + + switch (errorCode) + { + case NCErrorCodes.E_NULL_PTR: + RaiseNullArgExceptionForArgumentNumber<T>(argNumber); + break; + case NCErrorCodes.E_INVALID_ARG: + RaiseArgExceptionForArgumentNumber<T>(argNumber); + break; + case NCErrorCodes.E_ARGUMENT_OUT_OF_RANGE: + RaiseOORExceptionForArgumentNumber<T>(argNumber); + break; + case NCErrorCodes.E_INVALID_CTX: + throw new InvalidOperationException("The library context object is null or invalid"); + case NCErrorCodes.E_OPERATION_FAILED: + RaiseOperationFailedException(raiseOnFailure); + break; + case NCErrorCodes.E_VERSION_NOT_SUPPORTED: + throw new NotSupportedException("The requested version is not supported"); + + default: + if (raiseOnFailure) + { + throw new InvalidOperationException($"The operation failed with error, code: {errorCode} for arugment {argNumber:x}"); + } + break; + } + } + + private static void RaiseOperationFailedException(bool raise) + { + if (raise) + { + throw new InvalidOperationException("The operation failed for an unknown reason"); + } + } + + private static void RaiseNullArgExceptionForArgumentNumber<T>(int argNumber) where T : Delegate + { + //Get delegate parameters + Type type = typeof(T); + ParameterInfo arg = type.GetMethod("Invoke")!.GetParameters()[argNumber]; + throw new ArgumentNullException(arg.Name, "Argument is null or invalid cannot continue"); + } + + private static void RaiseArgExceptionForArgumentNumber<T>(int argNumber) where T : Delegate + { + //Get delegate parameters + Type type = typeof(T); + ParameterInfo arg = type.GetMethod("Invoke")!.GetParameters()[argNumber]; + throw new ArgumentException("Argument is null or invalid cannot continue", arg.Name); + } + + private static void RaiseOORExceptionForArgumentNumber<T>(int argNumber) where T : Delegate + { + //Get delegate parameters + Type type = typeof(T); + ParameterInfo arg = type.GetMethod("Invoke")!.GetParameters()[argNumber]; + throw new ArgumentOutOfRangeException(arg.Name, "Argument is out of range of acceptable values"); + } + } +} diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/LibNoscryptTests.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/LibNoscryptTests.cs index ffa9cb6..b8d9623 100644 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/LibNoscryptTests.cs +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/LibNoscryptTests.cs @@ -1,25 +1,15 @@ using Microsoft.VisualStudio.TestTools.UnitTesting; -using System; -using System.Text; -using System.Text.Json; - using VNLib.Hashing; using VNLib.Utils.Memory; -using VNLib.Utils.Extensions; -using VNLib.Utils.Cryptography.Noscrypt.Encryption; using VNLib.Utils.Cryptography.Noscrypt.Random; +using VNLib.Utils.Cryptography.Noscrypt.Singatures; namespace VNLib.Utils.Cryptography.Noscrypt.Tests { [TestClass()] public class LibNoscryptTests : IDisposable { - - const string NoscryptLibWinDebug = @"../../../../../../../build/windows/Debug/noscrypt.dll"; - const string NoscryptLinuxDebug = @"../../../../../../../build/linux/libnoscrypt.so"; - - //Keys generated using npx noskey package const string TestPrivateKeyHex = "98c642360e7163a66cee5d9a842b252345b6f3f3e21bd3b7635d5e6c20c7ea36"; const string TestPublicKeyHex = "0db15182c4ad3418b4fbab75304be7ade9cfa430a21c1c5320c9298f54ea5406"; @@ -27,56 +17,40 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Tests const string TestPrivateKeyHex2 = "3032cb8da355f9e72c9a94bbabae80ca99d3a38de1aed094b432a9fe3432e1f2"; const string TestPublicKeyHex2 = "421181660af5d39eb95e48a0a66c41ae393ba94ffeca94703ef81afbed724e5a"; - const string Nip44VectorTestFile = "nip44.vectors.json"; - #nullable disable private NoscryptLibrary _testLib; - private JsonDocument _testVectors; #nullable enable [TestInitialize] public void Initialize() { - _testLib = Environment.OSVersion.Platform switch - { - PlatformID.Win32NT => NoscryptLibrary.Load(NoscryptLibWinDebug), - PlatformID.Unix => NoscryptLibrary.Load(NoscryptLinuxDebug), - _ => throw new PlatformNotSupportedException() - }; - - _testVectors = JsonDocument.Parse(File.ReadAllText(Nip44VectorTestFile)); + _testLib = NoscryptLibrary.LoadDefault(); } - [TestMethod()] public void InitializeTest() { - //Random context seed - ReadOnlySpan<byte> seed = RandomHash.GetRandomBytes(32); - //Init new context and interface - NCContext context = _testLib.Initialize(MemoryUtil.Shared, seed); - - using NostrCrypto crypto = new(context, true); + using NCContext context = _testLib.Initialize(MemoryUtil.Shared, NCFallbackRandom.Shared); } [TestMethod()] public void ValidateSecretKeyTest() { //Random context seed - ReadOnlySpan<byte> seed = RandomHash.GetRandomBytes(32); ReadOnlySpan<byte> secretKey = RandomHash.GetRandomBytes(32); Span<byte> publicKey = stackalloc byte[32]; - using NostrCrypto crypto = _testLib.InitializeCrypto(MemoryUtil.Shared, seed); + using NCContext context = _testLib.Initialize(MemoryUtil.Shared, NCFallbackRandom.Shared); //validate the secret key - Assert.IsTrue(crypto.ValidateSecretKey(in NCUtil.AsSecretKey(secretKey))); + Assert.IsTrue(NCKeyUtil.ValidateSecretKey(context, in NCKeyUtil.AsSecretKey(secretKey))); //Generate the public key - crypto.GetPublicKey( - in NCUtil.AsSecretKey(secretKey), - ref NCUtil.AsPublicKey(publicKey) + NCKeyUtil.GetPublicKey( + context, + in NCKeyUtil.AsSecretKey(secretKey), + ref NCKeyUtil.AsPublicKey(publicKey) ); //Make sure the does not contain all zeros @@ -86,33 +60,31 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Tests [TestMethod()] public void TestGetPublicKey() { - //Random context seed - ReadOnlySpan<byte> seed = RandomHash.GetRandomBytes(32); - - using NostrCrypto crypto = _testLib.InitializeCrypto(MemoryUtil.Shared, seed); + using NCContext context = _testLib.Initialize(MemoryUtil.Shared, NCFallbackRandom.Shared); //Test known key 1 TestKnownKeys( - crypto, + context, Convert.FromHexString(TestPrivateKeyHex), Convert.FromHexString(TestPublicKeyHex) ); //Test known key 2 TestKnownKeys( - crypto, + context, Convert.FromHexString(TestPrivateKeyHex2), Convert.FromHexString(TestPublicKeyHex2) ); - static void TestKnownKeys(NostrCrypto lib, ReadOnlySpan<byte> knownSec, ReadOnlySpan<byte> kownPub) + static void TestKnownKeys(NCContext context, ReadOnlySpan<byte> knownSec, ReadOnlySpan<byte> kownPub) { NCPublicKey pubKey; //Invoke test function - lib.GetPublicKey( - in NCUtil.AsSecretKey(knownSec), + NCKeyUtil.GetPublicKey( + context, + in NCKeyUtil.AsSecretKey(knownSec), ref pubKey ); @@ -125,176 +97,104 @@ namespace VNLib.Utils.Cryptography.Noscrypt.Tests [TestMethod()] public void TestPublicApiArgValidations() { - //Random context seed - ReadOnlySpan<byte> seed = RandomHash.GetRandomBytes(32); - - using NostrCrypto crypto = _testLib.InitializeCrypto(MemoryUtil.Shared, seed); + using NCContext context = _testLib.Initialize(MemoryUtil.Shared, NCFallbackRandom.Shared); + byte[] bin16 = new byte[16]; + byte[] bin32 = new byte[32]; + byte[] bin64 = new byte[64]; NCSecretKey secKey = default; NCPublicKey pubKey = default; //noThrow (its a bad sec key but it should not throw) - crypto.ValidateSecretKey(ref secKey); - Assert.ThrowsException<ArgumentNullException>(() => crypto.ValidateSecretKey(ref NCSecretKey.NullRef)); + NCKeyUtil.ValidateSecretKey(context, in secKey); + Assert.ThrowsException<ArgumentNullException>(() => NCKeyUtil.ValidateSecretKey(null!, ref NCSecretKey.NullRef)); + Assert.ThrowsException<ArgumentNullException>(() => NCKeyUtil.ValidateSecretKey(context, ref NCSecretKey.NullRef)); //public key - Assert.ThrowsException<ArgumentNullException>(() => crypto.GetPublicKey(ref NCSecretKey.NullRef, ref pubKey)); - Assert.ThrowsException<ArgumentNullException>(() => crypto.GetPublicKey(in secKey, ref NCPublicKey.NullRef)); - } - - [TestMethod()] - public void CorrectEncryptionTest() - { - using NostrCrypto nc = _testLib.InitializeCrypto(MemoryUtil.Shared, RandomHash.GetRandomBytes(32)); - - using NoscryptCipher cipher = nc.AllocCipher(NoscryptCipherVersion.Nip44, NoscryptCipherFlags.EncryptDefault); - - using IMemoryHandle<byte> ctBuffer = MemoryUtil.SafeAllocNearestPage(1200, false); - - foreach (EncryptionVector v in GetEncryptionVectors()) - { - - ReadOnlySpan<byte> secKey1 = Convert.FromHexString(v.sec1); - ReadOnlySpan<byte> secKey2 = Convert.FromHexString(v.sec2); - ReadOnlySpan<byte> plainText = Encoding.UTF8.GetBytes(v.plaintext); - ReadOnlySpan<byte> nonce = Convert.FromHexString(v.nonce); - ReadOnlySpan<byte> message = Convert.FromBase64String(v.payload); - - NCPublicKey pub2; - - //Recover public keys - nc.GetPublicKey(in NCUtil.AsSecretKey(secKey2), ref pub2); - - //Assign existing nonce - nonce.CopyTo(cipher.IvBuffer); - - cipher.Update( - in NCUtil.AsSecretKey(secKey1), - in pub2, - plainText - ); - - Span<byte> outputBuffer = ctBuffer.AsSpan(0, cipher.GetOutputSize()); - - Assert.AreEqual<int>(cipher.ReadOutput(outputBuffer), message.Length); - - //Make sure the cipher text matches the expected payload - if (!outputBuffer.SequenceEqual(message)) - { - Console.WriteLine($"Input data: {v.plaintext}"); - Console.WriteLine($" \n{Convert.ToHexString(outputBuffer)}\n{Convert.ToHexString(message)}"); - Assert.Fail($"Cipher text does not match expected message"); - } - } - } - - [TestMethod()] - public void CorrectDecryptionTest() - { - using NostrCrypto nc = _testLib.InitializeCrypto(MemoryUtil.Shared, NCFallbackRandom.Shared); - - using NoscryptCipher msgCipher = nc.AllocCipher(NoscryptCipherVersion.Nip44, NoscryptCipherFlags.DecryptDefault); - - using IMemoryHandle<byte> ptBuffer = MemoryUtil.SafeAllocNearestPage(1200, false); - - foreach (EncryptionVector vector in GetEncryptionVectors()) - { - ReadOnlySpan<byte> secKey1 = Convert.FromHexString(vector.sec1); - ReadOnlySpan<byte> secKey2 = Convert.FromHexString(vector.sec2); - ReadOnlySpan<byte> expectedPt = Encoding.UTF8.GetBytes(vector.plaintext); - ReadOnlySpan<byte> message = Convert.FromBase64String(vector.payload); - - NCPublicKey pub2 = default; + Assert.ThrowsException<ArgumentNullException>(() => NCKeyUtil.GetPublicKey(null!, in secKey, ref pubKey)); + Assert.ThrowsException<ArgumentNullException>(() => NCKeyUtil.GetPublicKey(context, ref NCSecretKey.NullRef, ref pubKey)); + Assert.ThrowsException<ArgumentNullException>(() => NCKeyUtil.GetPublicKey(context, in secKey, ref NCPublicKey.NullRef)); + + /* + * VERIFY DATA + */ + //Null context + Assert.ThrowsException<ArgumentNullException>(() => + NCSignatureUtil.VerifyData(null!, ref pubKey, bin32, bin64) + ); - //Recover public keys - nc.GetPublicKey(in NCUtil.AsSecretKey(secKey2), ref pub2); + //Null pubkey + Assert.ThrowsException<ArgumentNullException>(() => + NCSignatureUtil.VerifyData(context, ref NCPublicKey.NullRef, bin32, bin64) + ); - //update performs the decryption operation (mac is also verified by default) - msgCipher.Update( - in NCUtil.AsSecretKey(secKey1), - in pub2, - message - ); + //No data buffer + Assert.ThrowsException<ArgumentOutOfRangeException>(() => + NCSignatureUtil.VerifyData(context, ref pubKey, [], bin64) + ); - int outLen = msgCipher.GetOutputSize(); - Assert.IsTrue(outLen == expectedPt.Length); + //No signature + Assert.ThrowsException<ArgumentOutOfRangeException>(() => + NCSignatureUtil.VerifyData(context, ref pubKey, bin32, []) + ); - Span<byte> plaintext = ptBuffer.AsSpan(0, outLen); + //Signature too small + Assert.ThrowsException<ArgumentOutOfRangeException>(() => + NCSignatureUtil.VerifyData(context, ref pubKey, bin32, bin32) + ); - msgCipher.ReadOutput(plaintext); + /* + * SIGN DATA + */ - if (!plaintext.SequenceEqual(expectedPt)) - { - Console.WriteLine($"Input data: {vector.plaintext}"); - Console.WriteLine($" \n{Convert.ToHexString(plaintext)}\n{Convert.ToHexString(expectedPt)}"); - Assert.Fail("Decrypted data does not match expected plaintext"); - } - } - } + //Null context + Assert.ThrowsException<ArgumentNullException>(() => + NCSignatureUtil.SignData(null!, ref secKey, bin32, bin32, bin64) + ); + //Null secret key + Assert.ThrowsException<ArgumentNullException>(() => + NCSignatureUtil.SignData(context, ref NCSecretKey.NullRef, bin32, bin32, bin64) + ); - //Converstation key is only available in debug builds -#if DEBUG + //No entropy + Assert.ThrowsException<ArgumentOutOfRangeException>(() => + NCSignatureUtil.SignData(context, ref secKey, [], bin32, bin64) + ); - [TestMethod()] - public void ConverstationKeyTest() - { - using NostrCrypto nc = _testLib.InitializeCrypto(MemoryUtil.Shared, RandomHash.GetRandomBytes(32)); - - Span<byte> convKeyOut = stackalloc byte[32]; + //No data + Assert.ThrowsException<ArgumentOutOfRangeException>(() => + NCSignatureUtil.SignData(context, ref secKey, bin32, [], bin64) + ); - foreach (EncryptionVector v in GetEncryptionVectors()) - { - ReadOnlySpan<byte> secKey1 = Convert.FromHexString(v.sec1); - ReadOnlySpan<byte> secKey2 = Convert.FromHexString(v.sec2); - ReadOnlySpan<byte> conversationKey = Convert.FromHexString(v.conversation_key); + //No signature + Assert.ThrowsException<ArgumentOutOfRangeException>(() => + NCSignatureUtil.SignData(context, ref secKey, bin32, bin32, []) + ); - NCPublicKey pubkey2 = default; - nc.GetPublicKey(in NCUtil.AsSecretKey(secKey2), ref pubkey2); + //Signature too small + Assert.ThrowsException<ArgumentOutOfRangeException>(() => + NCSignatureUtil.SignData(context, ref secKey, bin32, bin32, bin32) + ); - nc.GetConverstationKey( - in NCUtil.AsSecretKey(secKey1), - in pubkey2, - convKeyOut - ); + //Entropy too small + Assert.ThrowsException<ArgumentOutOfRangeException>(() => + NCSignatureUtil.SignData(context, ref secKey, bin16, bin32, bin32) + ); - Assert.IsTrue(conversationKey.SequenceEqual(convKeyOut)); + /* + * Cipher api + */ - MemoryUtil.InitializeBlock(convKeyOut); - } - } -#endif + NoscryptSigner signer = new(context, NCFallbackRandom.Shared); - private EncryptionVector[] GetEncryptionVectors() - { - return _testVectors.RootElement.GetProperty("v2") - .GetProperty("valid") - .GetProperty("encrypt_decrypt") - .EnumerateArray() - .Select(v => v.Deserialize<EncryptionVector>()!) - .ToArray(); + } void IDisposable.Dispose() { _testLib.Dispose(); - _testVectors.Dispose(); GC.SuppressFinalize(this); } - - private sealed class EncryptionVector - { - public string sec1 { get; set; } = string.Empty; - - public string sec2 { get; set; } = string.Empty; - - public string nonce { get; set; } = string.Empty; - - public string plaintext { get; set; } = string.Empty; - - public string payload { get; set; } = string.Empty; - - public string conversation_key { get; set; } = string.Empty; - } } } diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/NoscryptVectorTests.cs b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/NoscryptVectorTests.cs new file mode 100644 index 0000000..1a2f5d2 --- /dev/null +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/NoscryptVectorTests.cs @@ -0,0 +1,185 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using System; +using System.Text; +using System.Text.Json; +using VNLib.Utils.Memory; +using VNLib.Utils.Extensions; +using VNLib.Utils.Cryptography.Noscrypt.Encryption; +using VNLib.Utils.Cryptography.Noscrypt.Random; + +namespace VNLib.Utils.Cryptography.Noscrypt.Tests +{ + + [TestClass()] + public class NoscryptVectorTests : IDisposable + { + const string Nip44VectorTestFile = "nip44.vectors.json"; + +#nullable disable + private NoscryptLibrary _testLib; + private JsonDocument _testVectors; +#nullable enable + + [TestInitialize] + public void Initialize() + { + _testLib = NoscryptLibrary.LoadDefault(); + _testVectors = JsonDocument.Parse(File.ReadAllText(Nip44VectorTestFile)); + } + + [TestMethod()] + public void CorrectEncryptionTest() + { + using NCContext context = _testLib.Initialize(MemoryUtil.Shared, NCFallbackRandom.Shared); + using NoscryptMessageCipher cipher = NoscryptMessageCipher.Create(context, NoscryptCipherVersion.Nip44, NoscryptCipherFlags.EncryptDefault); + + using IMemoryHandle<byte> ctBuffer = MemoryUtil.SafeAllocNearestPage(1200, false); + + foreach (EncryptionVector v in GetEncryptionVectors()) + { + + ReadOnlySpan<byte> secKey1 = Convert.FromHexString(v.sec1); + ReadOnlySpan<byte> secKey2 = Convert.FromHexString(v.sec2); + ReadOnlySpan<byte> plainText = Encoding.UTF8.GetBytes(v.plaintext); + ReadOnlySpan<byte> nonce = Convert.FromHexString(v.nonce); + ReadOnlySpan<byte> message = Convert.FromBase64String(v.payload); + + NCPublicKey pub2; + + //Recover public keys + NCKeyUtil.GetPublicKey(context, in NCKeyUtil.AsSecretKey(secKey2), ref pub2); + + //Assign existing nonce + nonce.CopyTo(cipher.IvBuffer); + + cipher.Update( + in NCKeyUtil.AsSecretKey(secKey1), + in pub2, + plainText + ); + + Span<byte> outputBuffer = ctBuffer.AsSpan(0, cipher.GetOutputSize()); + + Assert.AreEqual<int>(cipher.ReadOutput(outputBuffer), message.Length); + + //Make sure the cipher text matches the expected payload + if (!outputBuffer.SequenceEqual(message)) + { + Console.WriteLine($"Input data: {v.plaintext}"); + Console.WriteLine($" \n{Convert.ToHexString(outputBuffer)}\n{Convert.ToHexString(message)}"); + Assert.Fail($"Cipher text does not match expected message"); + } + } + } + + [TestMethod()] + public void CorrectDecryptionTest() + { + using NCContext context = _testLib.Initialize(MemoryUtil.Shared, NCFallbackRandom.Shared); + using NoscryptMessageCipher msgCipher = NoscryptMessageCipher.Create(context, NoscryptCipherVersion.Nip44, NoscryptCipherFlags.DecryptDefault); + + using IMemoryHandle<byte> ptBuffer = MemoryUtil.SafeAllocNearestPage(1200, false); + + foreach (EncryptionVector vector in GetEncryptionVectors()) + { + ReadOnlySpan<byte> secKey1 = Convert.FromHexString(vector.sec1); + ReadOnlySpan<byte> secKey2 = Convert.FromHexString(vector.sec2); + ReadOnlySpan<byte> expectedPt = Encoding.UTF8.GetBytes(vector.plaintext); + ReadOnlySpan<byte> message = Convert.FromBase64String(vector.payload); + + NCPublicKey pub2 = default; + + //Recover public keys + NCKeyUtil.GetPublicKey(context, in NCKeyUtil.AsSecretKey(secKey2), ref pub2); + + //update performs the decryption operation (mac is also verified by default) + msgCipher.Update( + in NCKeyUtil.AsSecretKey(secKey1), + in pub2, + message + ); + + int outLen = msgCipher.GetOutputSize(); + Assert.IsTrue(outLen == expectedPt.Length); + + Span<byte> plaintext = ptBuffer.AsSpan(0, outLen); + + msgCipher.ReadOutput(plaintext); + + if (!plaintext.SequenceEqual(expectedPt)) + { + Console.WriteLine($"Input data: {vector.plaintext}"); + Console.WriteLine($" \n{Convert.ToHexString(plaintext)}\n{Convert.ToHexString(expectedPt)}"); + Assert.Fail("Decrypted data does not match expected plaintext"); + } + } + } + + + //Converstation key is only available in debug builds +#if DEBUG + + [TestMethod()] + public void ConverstationKeyTest() + { + using NCContext context = _testLib.Initialize(MemoryUtil.Shared, NCFallbackRandom.Shared); + + Span<byte> convKeyOut = stackalloc byte[32]; + + foreach (EncryptionVector v in GetEncryptionVectors()) + { + ReadOnlySpan<byte> secKey1 = Convert.FromHexString(v.sec1); + ReadOnlySpan<byte> secKey2 = Convert.FromHexString(v.sec2); + ReadOnlySpan<byte> conversationKey = Convert.FromHexString(v.conversation_key); + + NCPublicKey pubkey2 = default; + NCKeyUtil.GetPublicKey(context, in NCKeyUtil.AsSecretKey(secKey2), ref pubkey2); + + NCCipherUtil.GetConverstationKey( + context, + in NCKeyUtil.AsSecretKey(secKey1), + in pubkey2, + convKeyOut + ); + + Assert.IsTrue(conversationKey.SequenceEqual(convKeyOut)); + + MemoryUtil.InitializeBlock(convKeyOut); + } + } +#endif + + private EncryptionVector[] GetEncryptionVectors() + { + return _testVectors.RootElement.GetProperty("v2") + .GetProperty("valid") + .GetProperty("encrypt_decrypt") + .EnumerateArray() + .Select(v => v.Deserialize<EncryptionVector>()!) + .ToArray(); + } + + void IDisposable.Dispose() + { + _testLib.Dispose(); + _testVectors.Dispose(); + GC.SuppressFinalize(this); + } + + private sealed class EncryptionVector + { + public string sec1 { get; set; } = string.Empty; + + public string sec2 { get; set; } = string.Empty; + + public string nonce { get; set; } = string.Empty; + + public string plaintext { get; set; } = string.Empty; + + public string payload { get; set; } = string.Empty; + + public string conversation_key { get; set; } = string.Empty; + } + } +} diff --git a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/NVault.Crypto.NoscryptTests.csproj b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/VNLib.Utils.Cryptography.NoscryptTests.csproj index 5917b15..a4542a6 100644 --- a/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/NVault.Crypto.NoscryptTests.csproj +++ b/wrappers/dotnet/VNLib.Utils.Cryptography.Noscrypt/tests/VNLib.Utils.Cryptography.NoscryptTests.csproj @@ -1,32 +1,30 @@ -<Project Sdk="Microsoft.NET.Sdk"> - +<Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <TargetFramework>net8.0</TargetFramework> <ImplicitUsings>enable</ImplicitUsings> <Nullable>enable</Nullable> - <IsPackable>false</IsPackable> <IsTestProject>true</IsTestProject> + <AssemblyVersion>0.2.0.0</AssemblyVersion> + <FileVersion>0.2.0.0</FileVersion> + <InformationalVersion>0.2.0-c-sharp.95+Branch.c-sharp.Sha.6a4a464d9fdc7821cd5c5695656a3fe385497cc5</InformationalVersion> + <Version>0.2.0-c-sharp0095</Version> </PropertyGroup> - <ItemGroup> - <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" /> - <PackageReference Include="MSTest.TestAdapter" Version="3.4.1" /> - <PackageReference Include="MSTest.TestFramework" Version="3.4.1" /> + <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" /> + <PackageReference Include="MSTest.TestAdapter" Version="3.6.1" /> + <PackageReference Include="MSTest.TestFramework" Version="3.6.1" /> <PackageReference Include="coverlet.collector" Version="6.0.2"> <PrivateAssets>all</PrivateAssets> <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> </PackageReference> </ItemGroup> - <ItemGroup> <ProjectReference Include="..\src\VNLib.Utils.Cryptography.Noscrypt.csproj" /> </ItemGroup> - <ItemGroup> <None Update="nip44.vectors.json"> <CopyToOutputDirectory>Always</CopyToOutputDirectory> </None> </ItemGroup> - -</Project> +</Project>
\ No newline at end of file |