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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
// 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.Buffers.Binary;
using System.Runtime.InteropServices;
using VNLib.Utils.Memory;
using static VNLib.Utils.Cryptography.Noscrypt.LibNoscrypt;
namespace VNLib.Utils.Cryptography.Noscrypt
{
/// <summary>
/// Provides a set of utility methods for working with the Noscrypt library
/// </summary>
public static class Nip44Util
{
/// <summary>
/// Calculates the required NIP44 encryption buffer size for
/// the specified input data size
/// </summary>
/// <param name="dataSize">The size (in bytes) of the encoded data to encrypt</param>
/// <returns>The exact size of the padded buffer output</returns>
public static int CalcBufferSize(int dataSize)
{
/*
* Taken from https://github.com/nostr-protocol/nips/blob/master/44.md
*
* Not gonna lie, kinda dumb branches. I guess they want to save space
* with really tiny messages... Dunno, but whatever RTFM
*/
//Min message size is 32 bytes
int minSize = Math.Max(dataSize, 32);
//find the next power of 2 that will fit the min size
int nexPower = 1 << ((int)Math.Log2(minSize - 1)) + 1;
int chunk = nexPower <= 256 ? 32 : nexPower / 8;
return (chunk * ((int)Math.Floor((double)((minSize - 1) / chunk)) + 1)) + sizeof(ushort);
}
/// <summary>
/// Calculates the final buffer size required to hold the encrypted data
/// </summary>
/// <param name="dataSize">The size (in bytes) of plaintext data to encrypt</param>
/// <returns>The number of bytes required to store the final nip44 message</returns>
public static int CalcFinalBufferSize(int dataSize)
{
/* version + nonce + payload + mac */
return CalcBufferSize(dataSize) + NC_ENCRYPTION_NONCE_SIZE + NC_ENCRYPTION_MAC_SIZE + 1;
}
/// <summary>
/// Formats the plaintext data into a buffer that can be properly encrypted.
/// The output buffer must be zeroed, or can be zeroed using the
/// <paramref name="zeroOutput"/> parameter. Use <see cref="CalcBufferSize(uint)"/>
/// to determine the required output buffer size.
/// </summary>
/// <param name="plaintextData">A buffer containing plaintext data to copy to the output</param>
/// <param name="output">The output data buffer to format</param>
/// <param name="zeroOutput">A value that indicates if the buffer should be zeroed before use</param>
public static void FormatBuffer(ReadOnlySpan<byte> plaintextData, Span<byte> output, bool zeroOutput)
{
//First zero out the buffer
if (zeroOutput)
{
MemoryUtil.InitializeBlock(output);
}
//Make sure the output buffer is large enough so we dont overrun it
ArgumentOutOfRangeException.ThrowIfLessThan(output.Length, plaintextData.Length + sizeof(ushort), nameof(output));
//Write the data size to the first 2 bytes
ushort dataSize = (ushort)plaintextData.Length;
BinaryPrimitives.WriteUInt16BigEndian(output, dataSize);
//Copy the plaintext data to the output buffer after the data size
MemoryUtil.Memmove(
in MemoryMarshal.GetReference(plaintextData),
0,
ref MemoryMarshal.GetReference(output),
sizeof(ushort),
(uint)plaintextData.Length
);
//We assume the remaining buffer is zeroed out
}
public static ReadOnlySpan<byte> GetNonceFromPayload(ReadOnlySpan<byte> message)
{
//The nonce is 32 bytes following the 1st byte version number of the message
return message.Slice(1, NC_ENCRYPTION_NONCE_SIZE);
}
public static ReadOnlySpan<byte> GetCiphertextFromPayload(ReadOnlySpan<byte> message)
{
//Message is between the nonce and the trailing mac
int payloadSize = message.Length - (1 + NC_ENCRYPTION_NONCE_SIZE + NC_ENCRYPTION_MAC_SIZE);
return message.Slice(1 + NC_ENCRYPTION_NONCE_SIZE, payloadSize);
}
public static ReadOnlySpan<byte> GetMacFromPayload(ReadOnlySpan<byte> message)
{
//The mac is the last 32 bytes of the message
return message[^NC_ENCRYPTION_MAC_SIZE..];
}
public static ReadOnlySpan<byte> GetNonceAndCiphertext(ReadOnlySpan<byte> message)
{
//The nonce is 32 bytes following the 1st byte version number of the message
return message.Slice(1, NC_ENCRYPTION_NONCE_SIZE + GetCiphertextFromPayload(message).Length);
}
public static byte GetMessageVersion(ReadOnlySpan<byte> message)
{
//The first byte is the message version
return message[0];
}
public static ReadOnlySpan<byte> GetPlaintextMessage(ReadOnlySpan<byte> plaintextPayload)
{
ushort ptLength = BinaryPrimitives.ReadUInt16BigEndian(plaintextPayload);
return plaintextPayload.Slice(sizeof(ushort), ptLength);
}
}
}
|
