1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
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;
}
}
|
