Skip to content

Commit d75a1ac

Browse files
MrMatthewLaytonMrMatthewLayton
committed
Added Merkle tree implementation and tests.
1 parent 1838c6b commit d75a1ac

14 files changed

+898
-7
lines changed

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

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
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.Security.Cryptography;
16+
17+
namespace OnixLabs.Security.Cryptography.UnitTests.Data;
18+
19+
public sealed record MerkleNode(string Text, int Number, DateTime Moment, Guid Identifier) : IHashable
20+
{
21+
public Hash ComputeHash(HashAlgorithm algorithm)
22+
{
23+
return Hash.Compute(algorithm, ToString());
24+
}
25+
}

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

+110
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,110 @@
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;
16+
using System.Collections.Generic;
17+
using System.Linq;
18+
using System.Security.Cryptography;
19+
using OnixLabs.Core;
20+
using OnixLabs.Security.Cryptography.UnitTests.Data;
21+
using Xunit;
22+
23+
namespace OnixLabs.Security.Cryptography.UnitTests;
24+
25+
public sealed class MerkleTreeGenericTests
26+
{
27+
private static readonly HashAlgorithm Algorithm = SHA256.Create();
28+
29+
private readonly IEnumerable<MerkleNode> setA =
30+
[
31+
new MerkleNode("abc", 123, "1953-05-08T01:00:59Z".ToDateTime(), Guid.Parse("18d1e14c-9762-4b2c-8774-3f053e8579e0")),
32+
new MerkleNode("def", 456, "1953-05-08T06:30:00Z".ToDateTime(), Guid.Parse("a5d0ad36-f9a6-4fb0-9374-aa658eb19a51")),
33+
new MerkleNode("hij", 789, "1953-05-08T12:00:33Z".ToDateTime(), Guid.Parse("0d324d48-d451-416e-ac4d-fed1a324d446")),
34+
new MerkleNode("klm", 101, "1953-05-08T18:30:00Z".ToDateTime(), Guid.Parse("dc2bb378-114e-4f5d-8674-92729a67fe3d")),
35+
new MerkleNode("nop", 112, "1953-05-08T23:00:59Z".ToDateTime(), Guid.Parse("193863c7-3bfa-4a3c-874a-a99d98b38358"))
36+
];
37+
38+
private readonly IEnumerable<MerkleNode> setB =
39+
[
40+
new MerkleNode("qrs", 123, "1900-05-08T01:00:59Z".ToDateTime(), Guid.Parse("893576c9-7cb1-4653-a7c4-21e5ba9e7275")),
41+
new MerkleNode("tuv", 456, "1901-05-08T06:30:00Z".ToDateTime(), Guid.Parse("e7543a7e-3a52-48f5-842e-9448931f1cde")),
42+
new MerkleNode("qxy", 789, "1902-05-08T12:00:33Z".ToDateTime(), Guid.Parse("d228ab75-d36a-4392-9c51-888a5b7f9db7")),
43+
new MerkleNode("zab", 101, "1903-05-08T18:30:00Z".ToDateTime(), Guid.Parse("f73180c0-1fc8-4492-ae5d-f0b8962177a8"))
44+
];
45+
46+
[Fact(DisplayName = "Identical Merkle trees should be considered equal")]
47+
public void IdenticalMerkleTreesShouldBeConsideredEqual()
48+
{
49+
// Given / When
50+
MerkleTree<MerkleNode> a = MerkleTree.Create(setA, Algorithm);
51+
MerkleTree<MerkleNode> b = MerkleTree.Create(setA, Algorithm);
52+
53+
// Then
54+
Assert.Equal(a, b);
55+
Assert.Equal(a.Hash, b.Hash);
56+
}
57+
58+
[Fact(DisplayName = "Different Merkle trees should not be considered equal")]
59+
public void DifferentMerkleTreesShouldNotBeConsideredEqual()
60+
{
61+
// Given / When
62+
MerkleTree<MerkleNode> a = MerkleTree.Create(setA, Algorithm);
63+
MerkleTree<MerkleNode> b = MerkleTree.Create(setB, Algorithm);
64+
65+
// Then
66+
Assert.NotEqual(a, b);
67+
Assert.NotEqual(a.Hash, b.Hash);
68+
}
69+
70+
[Fact(DisplayName = "MerkleTree.GetLeafHashes should produce the same leaf hashes that the tree was constructed with")]
71+
public void MerkleTreeGetLeafHashesShouldProduceTheSameLeafHashesThatTheTreeWasConstructedWith()
72+
{
73+
// Given
74+
IEnumerable<Hash> expected = setA.Select(value => value.ComputeHash(Algorithm));
75+
MerkleTree<MerkleNode> candidate = MerkleTree.Create(setA, Algorithm);
76+
77+
// When
78+
IEnumerable<Hash> actual = candidate.GetLeafHashes();
79+
80+
// Then
81+
Assert.Equal(expected, actual);
82+
}
83+
84+
[Fact(DisplayName = "MerkleTree.GetLeafValues should produce the same leaf values that the tree was constructed with")]
85+
public void MerkleTreeGetLeafValuesShouldProduceTheSameLeafValuesThatTheTreeWasConstructedWith()
86+
{
87+
// Given
88+
MerkleTree<MerkleNode> candidate = MerkleTree.Create(setA, Algorithm);
89+
90+
// When
91+
IEnumerable<MerkleNode> actual = candidate.GetLeafValues();
92+
93+
// Then
94+
Assert.Equal(setA, actual);
95+
}
96+
97+
[Fact(DisplayName = "MerkleTree.ToMerkleTree should produce a hash-only, non-generic Merkle tree that is equal in value")]
98+
public void MerkleTreeToMerkleTreeShouldProduceAHashOnlyNonGenericMerkleTreeThatIsEqualInValue()
99+
{
100+
// Given
101+
MerkleTree<MerkleNode> a = MerkleTree.Create(setA, Algorithm);
102+
103+
// When
104+
MerkleTree b = a.ToMerkleTree(Algorithm);
105+
106+
// Then
107+
Assert.Equal(a, b);
108+
Assert.Equal(a.Hash, b.Hash);
109+
}
110+
}

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

+83
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
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.Collections.Generic;
16+
using System.Linq;
17+
using System.Security.Cryptography;
18+
using Xunit;
19+
20+
namespace OnixLabs.Security.Cryptography.UnitTests;
21+
22+
public sealed class MerkleTreeTests
23+
{
24+
private static readonly HashAlgorithm Algorithm = SHA256.Create();
25+
26+
private readonly IEnumerable<Hash> setA = Enumerable.Range(123, 1357).Select(i => Hash.Compute(Algorithm, $"A{i}")).ToList();
27+
private readonly IEnumerable<Hash> setB = Enumerable.Range(100, 1000).Select(i => Hash.Compute(Algorithm, $"B{i}")).ToList();
28+
29+
[Fact(DisplayName = "Identical Merkle trees should be considered equal")]
30+
public void IdenticalMerkleTreesShouldBeConsideredEqual()
31+
{
32+
// Given / When
33+
MerkleTree a = MerkleTree.Create(setA, Algorithm);
34+
MerkleTree b = MerkleTree.Create(setA, Algorithm);
35+
36+
// Then
37+
Assert.Equal(a, b);
38+
Assert.Equal(a.Hash, b.Hash);
39+
}
40+
41+
[Fact(DisplayName = "Different Merkle trees should not be considered equal")]
42+
public void DifferentMerkleTreesShouldNotBeConsideredEqual()
43+
{
44+
// Given / When
45+
MerkleTree a = MerkleTree.Create(setA, Algorithm);
46+
MerkleTree b = MerkleTree.Create(setB, Algorithm);
47+
48+
// Then
49+
Assert.NotEqual(a, b);
50+
Assert.NotEqual(a.Hash, b.Hash);
51+
}
52+
53+
[Fact(DisplayName = "MerkleTree.GetLeafHashes should produce the same leaf hashes that the tree was constructed with")]
54+
public void MerkleTreeGetLeafHashesShouldProduceTheSameLeafHashesThatTheTreeWasConstructedWith()
55+
{
56+
// Given
57+
MerkleTree candidate = MerkleTree.Create(setA, Algorithm);
58+
59+
// When
60+
IEnumerable<Hash> actual = candidate.GetLeafHashes();
61+
62+
// Then
63+
Assert.Equal(setA, actual);
64+
}
65+
66+
[Fact(DisplayName = "MerkleTree.GetLeafHashes should obtain all leaf hashes from a Merkle tree constructed with 1 million hashes")]
67+
public void MerkleTreeGetLeafHashesShouldObtainAllLeafHashesFromAMerkleTreeConstructedWith1MillionHashes()
68+
{
69+
// Given
70+
IEnumerable<Hash> expected = Enumerable
71+
.Range(0, 1_000_000)
72+
.Select(value => Hash.Compute(Algorithm, value.ToString()))
73+
.ToList();
74+
75+
MerkleTree tree = MerkleTree.Create(expected, Algorithm);
76+
77+
// When
78+
IEnumerable<Hash> actual = tree.GetLeafHashes();
79+
80+
// Then
81+
Assert.Equal(expected, actual);
82+
}
83+
}

‎OnixLabs.Security.Cryptography/IHashable.cs

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
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.Security.Cryptography;
16+
17+
namespace OnixLabs.Security.Cryptography;
18+
19+
/// <summary>
20+
/// Defines a mechanism for computing the <see cref="Hash"/> of a data structure.
21+
/// </summary>
22+
public interface IHashable
23+
{
24+
/// <summary>
25+
/// Computes the <see cref="Hash"/> hash of the current object.
26+
/// </summary>
27+
/// <returns>Returns the computed <see cref="Hash"/> hash of the current object.</returns>
28+
Hash ComputeHash(HashAlgorithm algorithm);
29+
}

‎OnixLabs.Security.Cryptography/MerkleTree.Create.cs

+73
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
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.Collections.Generic;
16+
using System.Linq;
17+
using System.Security.Cryptography;
18+
using OnixLabs.Core.Linq;
19+
20+
namespace OnixLabs.Security.Cryptography;
21+
22+
public abstract partial class MerkleTree
23+
{
24+
/// <summary>
25+
/// Creates a Merkle tree from the specified <see cref="MerkleTree"/> leaf nodes.
26+
/// </summary>
27+
/// <param name="leaves">The Merkle tree leaf nodes from which to build a Merkle tree.</param>
28+
/// <param name="algorithm">The hash algorithm that will be used to hash together left-hand and right-hand <see cref="MerkleTree"/> nodes.</param>
29+
/// <returns>Returns a new <see cref="MerkleTree"/> node that represents the Merkle root.</returns>
30+
public static MerkleTree Create(IEnumerable<Hash> leaves, HashAlgorithm algorithm)
31+
{
32+
IReadOnlyList<MerkleTree> nodes = leaves.Select(leaf => new MerkleTreeLeafNode(leaf)).ToList();
33+
Require(nodes.IsNotEmpty(), "Cannot construct a Merkle tree from an empty list.", nameof(leaves));
34+
return BuildMerkleTree(nodes, algorithm);
35+
}
36+
37+
/// <summary>
38+
/// Creates a Merkle tree from the specified <see cref="IHashable"/> leaf nodes.
39+
/// </summary>
40+
/// <param name="leaves">The Merkle tree leaf nodes from which to build a Merkle tree.</param>
41+
/// <param name="algorithm">The hash algorithm that will be used to hash together left-hand and right-hand <see cref="MerkleTree"/> nodes.</param>
42+
/// <returns>Returns a new <see cref="MerkleTree"/> node that represents the Merkle root.</returns>
43+
public static MerkleTree<T> Create<T>(IEnumerable<T> leaves, HashAlgorithm algorithm) where T : IHashable
44+
{
45+
return MerkleTree<T>.Create(leaves, algorithm);
46+
}
47+
48+
/// <summary>
49+
/// Builds a Merkle tree from the specified <see cref="MerkleTree"/> nodes.
50+
/// </summary>
51+
/// <param name="nodes">The Merkle tree nodes from which to build a Merkle tree.</param>
52+
/// <param name="algorithm">The hash algorithm that will be used to hash together left-hand and right-hand <see cref="MerkleTree"/> nodes.</param>
53+
/// <returns>Returns a new <see cref="MerkleTree"/> node that represents the Merkle root.</returns>
54+
private static MerkleTree BuildMerkleTree(IReadOnlyList<MerkleTree> nodes, HashAlgorithm algorithm)
55+
{
56+
while (true)
57+
{
58+
if (nodes.IsSingle()) return nodes.Single();
59+
if (nodes.IsCountOdd()) nodes = nodes.Append(new MerkleTreeEmptyNode(algorithm)).ToArray();
60+
61+
List<MerkleTree> mergedNodes = [];
62+
63+
for (int index = 0; index < nodes.Count; index += 2)
64+
{
65+
MerkleTree left = nodes[index];
66+
MerkleTree right = nodes[index + 1];
67+
mergedNodes.Add(new MerkleTreeBranchNode(left, right, algorithm));
68+
}
69+
70+
nodes = mergedNodes.ToArray();
71+
}
72+
}
73+
}

‎OnixLabs.Security.Cryptography/MerkleTree.Equatable.cs

+73
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
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;
16+
17+
namespace OnixLabs.Security.Cryptography;
18+
19+
public abstract partial class MerkleTree
20+
{
21+
/// <summary>
22+
/// Checks whether the current object is equal to another object of the same type.
23+
/// </summary>
24+
/// <param name="other">An object to compare with the current object.</param>
25+
/// <returns>Returns <see langword="true"/> if the current object is equal to the other parameter; otherwise, <see langword="false"/>.</returns>
26+
public bool Equals(MerkleTree? other)
27+
{
28+
return ReferenceEquals(this, other)
29+
|| other is not null
30+
&& other.Hash == Hash;
31+
}
32+
33+
/// <summary>
34+
/// Checks for equality between the current instance and another object.
35+
/// </summary>
36+
/// <param name="obj">The object to check for equality.</param>
37+
/// <returns>Returns <see langword="true"/> if the object is equal to the current instance; otherwise, <see langword="false"/>.</returns>
38+
public override bool Equals(object? obj)
39+
{
40+
return Equals(obj as MerkleTree);
41+
}
42+
43+
/// <summary>
44+
/// Serves as a hash code function for the current instance.
45+
/// </summary>
46+
/// <returns>Returns a hash code for the current instance.</returns>
47+
public override int GetHashCode()
48+
{
49+
return HashCode.Combine(GetType(), Hash);
50+
}
51+
52+
/// <summary>
53+
/// Performs an equality comparison between two object instances.
54+
/// </summary>
55+
/// <param name="left">The left-hand instance to compare.</param>
56+
/// <param name="right">The right-hand instance to compare.</param>
57+
/// <returns>Returns <see langword="true"/> if the left-hand instance is equal to the right-hand instance; otherwise, <see langword="false"/>.</returns>
58+
public static bool operator ==(MerkleTree left, MerkleTree right)
59+
{
60+
return Equals(left, right);
61+
}
62+
63+
/// <summary>
64+
/// Performs an inequality comparison between two object instances.
65+
/// </summary>
66+
/// <param name="left">The left-hand instance to compare.</param>
67+
/// <param name="right">The right-hand instance to compare.</param>
68+
/// <returns>Returns <see langword="true"/> if the left-hand instance is not equal to the right-hand instance; otherwise, <see langword="false"/>.</returns>
69+
public static bool operator !=(MerkleTree left, MerkleTree right)
70+
{
71+
return !Equals(left, right);
72+
}
73+
}

0 commit comments

Comments
 (0)