Skip to content

Commit 96330c0

Browse files
MrMatthewLaytonMrMatthewLayton
authored
Added new hash compute methods, generic math factorial method, and constructor for Salt. (#76)
1 parent b48540e commit 96330c0

File tree

12 files changed

+292
-15
lines changed

12 files changed

+292
-15
lines changed

‎Directory.Build.props

+7
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
<Project>
2+
<PropertyGroup>
3+
<Version>9.1.0</Version>
4+
<PackageVersion>9.1.0</PackageVersion>
5+
<AssemblyVersion>9.1.0</AssemblyVersion>
6+
</PropertyGroup>
7+
</Project>

‎OnixLabs.Core/OnixLabs.Core.csproj

-2
Original file line numberDiff line numberDiff line change
@@ -7,11 +7,9 @@
77
<Title>OnixLabs.Core</Title>
88
<Authors>ONIXLabs</Authors>
99
<Description>ONIXLabs Core API for .NET</Description>
10-
<AssemblyVersion>9.0.0</AssemblyVersion>
1110
<NeutralLanguage>en</NeutralLanguage>
1211
<Copyright>Copyright © ONIXLabs 2020</Copyright>
1312
<RepositoryUrl>https://github.com/onix-labs/onixlabs-dotnet</RepositoryUrl>
14-
<PackageVersion>9.0.0</PackageVersion>
1513
</PropertyGroup>
1614
<PropertyGroup>
1715
<AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>

‎OnixLabs.Numerics.UnitTests/GenericMathFactorialTests.cs

+43
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System.Numerics;
16+
using Xunit;
17+
18+
namespace OnixLabs.Numerics.UnitTests;
19+
20+
public sealed class GenericMathFactorialTests
21+
{
22+
[Theory(DisplayName = "GenericMath.Factorial should produce the expected result")]
23+
[InlineData(0, 1)]
24+
[InlineData(1, 1)]
25+
[InlineData(2, 2)]
26+
[InlineData(3, 6)]
27+
[InlineData(4, 24)]
28+
[InlineData(5, 120)]
29+
[InlineData(6, 720)]
30+
[InlineData(7, 5040)]
31+
[InlineData(8, 40320)]
32+
[InlineData(9, 362880)]
33+
[InlineData(10, 3628800)]
34+
[InlineData(20, 2432902008176640000)]
35+
public void GenericMathFactorialShouldProduceExpectedResult(int value, BigInteger expected)
36+
{
37+
// When
38+
BigInteger actual = GenericMath.Factorial(value);
39+
40+
// Then
41+
Assert.Equal(expected, actual);
42+
}
43+
}

‎OnixLabs.Numerics/GenericMath.cs

+20
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,26 @@ public static class GenericMath
3131
/// <returns>Returns the delta, or difference between the specified numbers.</returns>
3232
public static T Delta<T>(T left, T right) where T : INumberBase<T> => T.Abs(left - right);
3333

34+
/// <summary>
35+
/// Gets the factorial of the specified <see cref="IBinaryInteger{TSelf}"/> value.
36+
/// </summary>
37+
/// <param name="value">The value for which the factorial will be computed.</param>
38+
/// <typeparam name="T">The underlying type of the <see cref="IBinaryInteger{TSelf}"/> value.</typeparam>
39+
/// <returns>Returns the factorial of the specified <see cref="IBinaryInteger{TSelf}"/> value.</returns>
40+
public static BigInteger Factorial<T>(T value) where T : IBinaryInteger<T>
41+
{
42+
Require(value >= T.Zero, "Value must be greater than or equal to zero.");
43+
44+
if(value <= T.One) return BigInteger.One;
45+
46+
BigInteger result = BigInteger.One;
47+
48+
for (T factor = T.One; factor <= value; factor++)
49+
result *= factor.ToBigInteger();
50+
51+
return result;
52+
}
53+
3454
/// <summary>
3555
/// Obtains the length of the integral component of the specified <see cref="INumberBase{TSelf}"/> value.
3656
/// </summary>

‎OnixLabs.Numerics/NumericsExtensions.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -25,12 +25,12 @@ namespace OnixLabs.Numerics;
2525
public static class NumericsExtensions
2626
{
2727
/// <summary>
28-
/// Gets the minimum value of a <see cref="decimal"/> as a <see cref="BigInteger"/>.
28+
/// Gets the minimum value of a <see cref="decimal"/> value as a <see cref="BigInteger"/>.
2929
/// </summary>
3030
private static readonly BigInteger MinDecimal = new(decimal.MinValue);
3131

3232
/// <summary>
33-
/// Gets the maximum value of a <see cref="decimal"/> as a <see cref="BigInteger"/>.
33+
/// Gets the maximum value of a <see cref="decimal"/> value as a <see cref="BigInteger"/>.
3434
/// </summary>
3535
private static readonly BigInteger MaxDecimal = new(decimal.MaxValue);
3636

‎OnixLabs.Numerics/OnixLabs.Numerics.csproj

+1-3
Original file line numberDiff line numberDiff line change
@@ -4,13 +4,11 @@
44
<Title>OnixLabs.Numerics</Title>
55
<Authors>ONIXLabs</Authors>
66
<Description>ONIXLabs Numerics API for .NET</Description>
7-
<AssemblyVersion>9.0.0</AssemblyVersion>
87
<NeutralLanguage>en</NeutralLanguage>
98
<Nullable>enable</Nullable>
109
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
1110
<Copyright>Copyright © ONIXLabs 2020</Copyright>
1211
<RepositoryUrl>https://github.com/onix-labs/onixlabs-dotnet</RepositoryUrl>
13-
<PackageVersion>9.0.0</PackageVersion>
1412
<LangVersion>12</LangVersion>
1513
</PropertyGroup>
1614
<PropertyGroup>
@@ -31,7 +29,7 @@
3129
<ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
3230
</PropertyGroup>
3331
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
34-
<DebugSymbols>true</DebugSymbols>
32+
<DebugSymbols>true</DebugSymbols>
3533
</PropertyGroup>
3634
<ItemGroup>
3735
<PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0">

‎OnixLabs.Security.Cryptography.UnitTests.Data/BinaryConvertible.cs

+7-1
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,13 @@
1616

1717
namespace OnixLabs.Security.Cryptography.UnitTests.Data;
1818

19-
public class BinaryConvertible(byte[] data) : ISpanBinaryConvertible
19+
public class BinaryConvertible(byte[] data) : IBinaryConvertible
20+
{
21+
public byte[] ToByteArray() => data;
22+
public ReadOnlySpan<byte> ToReadOnlySpan() => data;
23+
}
24+
25+
public class SpanBinaryConvertible(byte[] data) : ISpanBinaryConvertible
2026
{
2127
public byte[] ToByteArray() => data;
2228
public ReadOnlySpan<byte> ToReadOnlySpan() => data;

‎OnixLabs.Security.Cryptography.UnitTests/HashTests.cs

+169
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@
1616
using System.IO;
1717
using System.Security.Cryptography;
1818
using OnixLabs.Core;
19+
using OnixLabs.Security.Cryptography.UnitTests.Data;
1920
using Xunit;
2021

2122
namespace OnixLabs.Security.Cryptography.UnitTests;
@@ -233,6 +234,34 @@ public void HashComputeShouldProduceTheExpectedHashUsingAByteArray(string data,
233234
Assert.Equal(expected, actual);
234235
}
235236

237+
[Theory(DisplayName = "Hash.Compute should produce the expected hash using a span")]
238+
[InlineData("abc123", "MD5", "e99a18c428cb38d5f260853678922e03")]
239+
[InlineData("abc123", "SHA1", "6367c48dd193d56ea7b0baad25b19455e529f5ee")]
240+
[InlineData("abc123", "SHA256", "6ca13d52ca70c883e0f0bb101e425a89e8624de51db2d2392593af6a84118090")]
241+
[InlineData("abc123", "SHA384", "a31d79891919cad24f3264479d76884f581bee32e86778373db3a124de975dd86a40fc7f399b331133b281ab4b11a6ca")]
242+
[InlineData("abc123", "SHA512", "c70b5dd9ebfb6f51d09d4132b7170c9d20750a7852f00680f65658f0310e810056e6763c34c9a00b0e940076f54495c169fc2302cceb312039271c43469507dc")]
243+
public void HashComputeShouldProduceTheExpectedHashUsingASpan(string data, string algorithmName, string expected)
244+
{
245+
// Given
246+
ReadOnlySpan<byte> bytes = data.ToByteArray().AsSpan();
247+
HashAlgorithm algorithm = algorithmName switch
248+
{
249+
"MD5" => MD5.Create(),
250+
"SHA1" => SHA1.Create(),
251+
"SHA256" => SHA256.Create(),
252+
"SHA384" => SHA384.Create(),
253+
"SHA512" => SHA512.Create(),
254+
_ => throw new ArgumentException($"Unknown hash algorithm name: {algorithmName}.")
255+
};
256+
257+
// When
258+
Hash candidate = Hash.Compute(algorithm, bytes);
259+
string actual = candidate.ToString();
260+
261+
// Then
262+
Assert.Equal(expected, actual);
263+
}
264+
236265
[Theory(DisplayName = "Hash.Compute should produce the expected hash using a byte array with two rounds")]
237266
[InlineData("abc123", "MD5", "b106dc6352e5ec1f8aafd8c406d34d92")]
238267
[InlineData("abc123", "SHA1", "6691484ea6b50ddde1926a220da01fa9e575c18a")]
@@ -261,6 +290,34 @@ public void HashComputeShouldProduceTheExpectedHashUsingAByteArrayWithTwoRounds(
261290
Assert.Equal(expected, actual);
262291
}
263292

293+
[Theory(DisplayName = "Hash.Compute should produce the expected hash using a span with two rounds")]
294+
[InlineData("abc123", "MD5", "b106dc6352e5ec1f8aafd8c406d34d92")]
295+
[InlineData("abc123", "SHA1", "6691484ea6b50ddde1926a220da01fa9e575c18a")]
296+
[InlineData("abc123", "SHA256", "efaaeb3b1d1d85e8587ef0527ca43b9575ce8149ba1ee41583d3d19bd130daf8")]
297+
[InlineData("abc123", "SHA384", "d58e9a112b8c637df5d2e33af03ce738dd1c57657243d70d2fa8f76a99fa9a0e2f4abf50d9a88e8958f2d5f6fa002190")]
298+
[InlineData("abc123", "SHA512", "c2c9d705d7a1ed34247649bbe64c6edd2035e0a4c9ae1c063170f5ee2aeca09125cc0a8b30593c07a18801d6e0570de22e8dc40a59bc1f59a49834c05ed49949")]
299+
public void HashComputeShouldProduceTheExpectedHashUsingASpanWithTwoRounds(string data, string algorithmName, string expected)
300+
{
301+
// Given
302+
ReadOnlySpan<byte> bytes = data.ToByteArray().AsSpan();
303+
HashAlgorithm algorithm = algorithmName switch
304+
{
305+
"MD5" => MD5.Create(),
306+
"SHA1" => SHA1.Create(),
307+
"SHA256" => SHA256.Create(),
308+
"SHA384" => SHA384.Create(),
309+
"SHA512" => SHA512.Create(),
310+
_ => throw new ArgumentException($"Unknown hash algorithm name: {algorithmName}.")
311+
};
312+
313+
// When
314+
Hash candidate = Hash.Compute(algorithm, bytes, 2);
315+
string actual = candidate.ToString();
316+
317+
// Then
318+
Assert.Equal(expected, actual);
319+
}
320+
264321
[Theory(DisplayName = "Hash.Compute should produce the expected hash using a byte array with an offset and count")]
265322
[InlineData("abc123", 1, 3, "MD5", "b79f52be223290bd34f94e92aa8b0bdd")]
266323
[InlineData("abc123", 1, 3, "SHA1", "be4a30dd01a93831a222262d9fa288c4f016b822")]
@@ -289,6 +346,34 @@ public void HashComputeShouldProduceTheExpectedHashUsingAByteArrayWithAnOffsetAn
289346
Assert.Equal(expected, actual);
290347
}
291348

349+
[Theory(DisplayName = "Hash.Compute should produce the expected hash using a span with an offset and count")]
350+
[InlineData("abc123", 1, 3, "MD5", "b79f52be223290bd34f94e92aa8b0bdd")]
351+
[InlineData("abc123", 1, 3, "SHA1", "be4a30dd01a93831a222262d9fa288c4f016b822")]
352+
[InlineData("abc123", 1, 3, "SHA256", "fa54bf6e8e528001735fcc222c3ef5b99c46f469d9340deae3d9577818a6fe5a")]
353+
[InlineData("abc123", 1, 3, "SHA384", "3cfd879e784ed23f3e9142775218bbaf636bd5413d32583a10f79f6b63028cbe9e241273dabe293c27876db2ecbaa594")]
354+
[InlineData("abc123", 1, 3, "SHA512", "65f2fea7da1b1e470169d7f861000047ac78e00a024f5973322e5850d5fd61ceb94b7252629426bfa4beb3dafc9f55c747b5b2a8374f545e19148e61ef0057cc")]
355+
public void HashComputeShouldProduceTheExpectedHashUsingASpanWithAnOffsetAndCount(string data, int offset, int count, string algorithmName, string expected)
356+
{
357+
// Given
358+
ReadOnlySpan<byte> bytes = data.ToByteArray().AsSpan();
359+
HashAlgorithm algorithm = algorithmName switch
360+
{
361+
"MD5" => MD5.Create(),
362+
"SHA1" => SHA1.Create(),
363+
"SHA256" => SHA256.Create(),
364+
"SHA384" => SHA384.Create(),
365+
"SHA512" => SHA512.Create(),
366+
_ => throw new ArgumentException($"Unknown hash algorithm name: {algorithmName}.")
367+
};
368+
369+
// When
370+
Hash candidate = Hash.Compute(algorithm, bytes, offset, count);
371+
string actual = candidate.ToString();
372+
373+
// Then
374+
Assert.Equal(expected, actual);
375+
}
376+
292377
[Theory(DisplayName = "Hash.Compute should produce the expected hash using a byte array with an offset, count and two rounds")]
293378
[InlineData("abc123", 1, 3, "MD5", "05787e59f464916f6dfdf5bf5996e152")]
294379
[InlineData("abc123", 1, 3, "SHA1", "33dcbf41c6e49b12ad37b5dab4d95dcc6ee71f49")]
@@ -317,6 +402,34 @@ public void HashComputeShouldProduceTheExpectedHashUsingAByteArrayWithAnOffsetCo
317402
Assert.Equal(expected, actual);
318403
}
319404

405+
[Theory(DisplayName = "Hash.Compute should produce the expected hash using a span with an offset, count and two rounds")]
406+
[InlineData("abc123", 1, 3, "MD5", "05787e59f464916f6dfdf5bf5996e152")]
407+
[InlineData("abc123", 1, 3, "SHA1", "33dcbf41c6e49b12ad37b5dab4d95dcc6ee71f49")]
408+
[InlineData("abc123", 1, 3, "SHA256", "5a9828edeba2a57521b2d40648cc69a4e0c236111dfae612075399ba588eee91")]
409+
[InlineData("abc123", 1, 3, "SHA384", "5691be426e2e501f5598cfc0355fc7de2c1c15637daf98ee09bf7d1da75463bf33a96a2164facbd535515c54e5d56920")]
410+
[InlineData("abc123", 1, 3, "SHA512", "74da074abe82913bc91a3079ac7d55b8bb1e111d10647b31d6c881a93427ebc57a6c4aeca5efba612e9b71c38e6601a13df0e7d73e1530ed65453c8926404186")]
411+
public void HashComputeShouldProduceTheExpectedHashUsingASpanWithAnOffsetCountAndTwoRounds(string data, int offset, int count, string algorithmName, string expected)
412+
{
413+
// Given
414+
ReadOnlySpan<byte> bytes = data.ToByteArray().AsSpan();
415+
HashAlgorithm algorithm = algorithmName switch
416+
{
417+
"MD5" => MD5.Create(),
418+
"SHA1" => SHA1.Create(),
419+
"SHA256" => SHA256.Create(),
420+
"SHA384" => SHA384.Create(),
421+
"SHA512" => SHA512.Create(),
422+
_ => throw new ArgumentException($"Unknown hash algorithm name: {algorithmName}.")
423+
};
424+
425+
// When
426+
Hash candidate = Hash.Compute(algorithm, bytes, offset, count, 2);
427+
string actual = candidate.ToString();
428+
429+
// Then
430+
Assert.Equal(expected, actual);
431+
}
432+
320433
[Theory(DisplayName = "Hash.Compute should produce the expected hash using a stream")]
321434
[InlineData("abc123", "MD5", "e99a18c428cb38d5f260853678922e03")]
322435
[InlineData("abc123", "SHA1", "6367c48dd193d56ea7b0baad25b19455e529f5ee")]
@@ -373,6 +486,62 @@ public void HashComputeShouldProduceTheExpectedHashUsingAStreamAndTwoRounds(stri
373486
Assert.Equal(expected, actual);
374487
}
375488

489+
[Theory(DisplayName = "Hash.Compute should produce the expected hash using an IBinaryConvertible")]
490+
[InlineData("abc123", "MD5", "e99a18c428cb38d5f260853678922e03")]
491+
[InlineData("abc123", "SHA1", "6367c48dd193d56ea7b0baad25b19455e529f5ee")]
492+
[InlineData("abc123", "SHA256", "6ca13d52ca70c883e0f0bb101e425a89e8624de51db2d2392593af6a84118090")]
493+
[InlineData("abc123", "SHA384", "a31d79891919cad24f3264479d76884f581bee32e86778373db3a124de975dd86a40fc7f399b331133b281ab4b11a6ca")]
494+
[InlineData("abc123", "SHA512", "c70b5dd9ebfb6f51d09d4132b7170c9d20750a7852f00680f65658f0310e810056e6763c34c9a00b0e940076f54495c169fc2302cceb312039271c43469507dc")]
495+
public void HashComputeShouldProduceTheExpectedHashUsingAnIBinaryConvertible(string data, string algorithmName, string expected)
496+
{
497+
// Given
498+
BinaryConvertible bytes = new(data.ToByteArray());
499+
HashAlgorithm algorithm = algorithmName switch
500+
{
501+
"MD5" => MD5.Create(),
502+
"SHA1" => SHA1.Create(),
503+
"SHA256" => SHA256.Create(),
504+
"SHA384" => SHA384.Create(),
505+
"SHA512" => SHA512.Create(),
506+
_ => throw new ArgumentException($"Unknown hash algorithm name: {algorithmName}.")
507+
};
508+
509+
// When
510+
Hash candidate = Hash.Compute(algorithm, bytes);
511+
string actual = candidate.ToString();
512+
513+
// Then
514+
Assert.Equal(expected, actual);
515+
}
516+
517+
[Theory(DisplayName = "Hash.Compute should produce the expected hash using an ISpanBinaryConvertible")]
518+
[InlineData("abc123", "MD5", "e99a18c428cb38d5f260853678922e03")]
519+
[InlineData("abc123", "SHA1", "6367c48dd193d56ea7b0baad25b19455e529f5ee")]
520+
[InlineData("abc123", "SHA256", "6ca13d52ca70c883e0f0bb101e425a89e8624de51db2d2392593af6a84118090")]
521+
[InlineData("abc123", "SHA384", "a31d79891919cad24f3264479d76884f581bee32e86778373db3a124de975dd86a40fc7f399b331133b281ab4b11a6ca")]
522+
[InlineData("abc123", "SHA512", "c70b5dd9ebfb6f51d09d4132b7170c9d20750a7852f00680f65658f0310e810056e6763c34c9a00b0e940076f54495c169fc2302cceb312039271c43469507dc")]
523+
public void HashComputeShouldProduceTheExpectedHashUsingAnISpanBinaryConvertible(string data, string algorithmName, string expected)
524+
{
525+
// Given
526+
SpanBinaryConvertible bytes = new(data.ToByteArray());
527+
HashAlgorithm algorithm = algorithmName switch
528+
{
529+
"MD5" => MD5.Create(),
530+
"SHA1" => SHA1.Create(),
531+
"SHA256" => SHA256.Create(),
532+
"SHA384" => SHA384.Create(),
533+
"SHA512" => SHA512.Create(),
534+
_ => throw new ArgumentException($"Unknown hash algorithm name: {algorithmName}.")
535+
};
536+
537+
// When
538+
Hash candidate = Hash.Compute(algorithm, bytes);
539+
string actual = candidate.ToString();
540+
541+
// Then
542+
Assert.Equal(expected, actual);
543+
}
544+
376545
[Fact(DisplayName = "Hash.ToNamedHash should produce the expected result")]
377546
public void HashToNamedHashShouldProduceExpectedResult()
378547
{

0 commit comments

Comments
 (0)