mirror of https://github.com/Squidex/squidex.git
Browse Source
* Improve performance. * Minor formatting. * Mini improvements. * Fix hasher.pull/1012/head
Sebastian Stehle
3 years ago
committed by
GitHub
GitHub
27 changed files with 943 additions and 397 deletions
@ -0,0 +1,252 @@ |
|||
// ==========================================================================
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex UG (haftungsbeschraenkt)
|
|||
// All rights reserved. Licensed under the MIT license.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Buffers; |
|||
using System.Security.Cryptography; |
|||
using System.Text; |
|||
|
|||
namespace Squidex.Infrastructure; |
|||
|
|||
public static class HashExtensions |
|||
{ |
|||
private const int MaxStackSize = 128; |
|||
private delegate int HashMethod(ReadOnlySpan<byte> source, Span<byte> destination); |
|||
private delegate string EncodeMethod(ReadOnlySpan<byte> source); |
|||
private static readonly HashMethod HashMD5 = MD5.HashData; |
|||
private static readonly HashMethod HashSHA256 = SHA256.HashData; |
|||
private static readonly HashMethod HashSHA512 = SHA512.HashData; |
|||
private static readonly EncodeMethod EncodeUTF8 = Encoding.UTF8.GetString; |
|||
private static readonly EncodeMethod EncodeBase64 = input => Convert.ToBase64String(input, default); |
|||
|
|||
public static string ToSha256Base64(this string value) |
|||
{ |
|||
return ToHashed(value, HashSHA256, SHA256.HashSizeInBits, Encoding.UTF8, EncodeBase64); |
|||
} |
|||
|
|||
public static string ToSha256Base64(this ReadOnlySpan<byte> value) |
|||
{ |
|||
return ToHashed(value, HashSHA256, SHA256.HashSizeInBits, EncodeBase64); |
|||
} |
|||
|
|||
public static string ToSha512(this string value) |
|||
{ |
|||
return ToHashed(value, HashSHA512, SHA512.HashSizeInBits, Encoding.UTF8, EncodeUTF8); |
|||
} |
|||
|
|||
public static string ToSha512(this ReadOnlySpan<byte> value) |
|||
{ |
|||
return ToHashed(value, HashSHA512, SHA512.HashSizeInBits, EncodeUTF8); |
|||
} |
|||
|
|||
public static string ToSha256(this string value) |
|||
{ |
|||
return ToHashed(value, HashSHA256, SHA256.HashSizeInBits, Encoding.UTF8, EncodeUTF8); |
|||
} |
|||
|
|||
public static string ToSha256(this ReadOnlySpan<byte> value) |
|||
{ |
|||
return ToHashed(value, HashSHA256, SHA256.HashSizeInBits, EncodeUTF8); |
|||
} |
|||
|
|||
public static string ToMD5(this string value) |
|||
{ |
|||
return ToHashed(value, HashMD5, MD5.HashSizeInBits, Encoding.UTF8, EncodeUTF8); |
|||
} |
|||
|
|||
public static string ToMD5(this ReadOnlySpan<byte> value) |
|||
{ |
|||
return ToHashed(value, HashMD5, MD5.HashSizeInBits, EncodeUTF8); |
|||
} |
|||
|
|||
private static string ToHashed(this string value, HashMethod algorithm, int hashSize, Encoding encoding, EncodeMethod encode) |
|||
{ |
|||
if (string.IsNullOrWhiteSpace(value)) |
|||
{ |
|||
return value; |
|||
} |
|||
|
|||
string result; |
|||
|
|||
var length = encoding.GetByteCount(value); |
|||
|
|||
if (length > MaxStackSize) |
|||
{ |
|||
var buffer = ArrayPool<byte>.Shared.Rent(length); |
|||
try |
|||
{ |
|||
result = ConvertCore(algorithm, hashSize, value.AsSpan(), buffer, encode, encoding); |
|||
} |
|||
finally |
|||
{ |
|||
ArrayPool<byte>.Shared.Return(buffer); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
Span<byte> buffer = stackalloc byte[length]; |
|||
|
|||
result = ConvertCore(algorithm, hashSize, value.AsSpan(), buffer, encode, encoding); |
|||
} |
|||
|
|||
static string ConvertCore(HashMethod algorithm, int hashSize, ReadOnlySpan<char> source, Span<byte> destination, EncodeMethod encode, Encoding encoding) |
|||
{ |
|||
var written = encoding.GetBytes(source, destination); |
|||
|
|||
return ToHashed(destination[..written], algorithm, hashSize, encode); |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
|
|||
private static string ToHashed(ReadOnlySpan<byte> bytes, HashMethod algorithm, int hashSize, EncodeMethod encode) |
|||
{ |
|||
if (bytes.Length == 0) |
|||
{ |
|||
return string.Empty; |
|||
} |
|||
|
|||
string result; |
|||
|
|||
var length = hashSize / 8; |
|||
|
|||
if (length > MaxStackSize) |
|||
{ |
|||
var buffer = ArrayPool<byte>.Shared.Rent(length); |
|||
try |
|||
{ |
|||
result = ConvertCore(algorithm, bytes, buffer, encode); |
|||
} |
|||
finally |
|||
{ |
|||
ArrayPool<byte>.Shared.Return(buffer); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
Span<byte> buffer = stackalloc byte[length]; |
|||
|
|||
return ConvertCore(algorithm, bytes, buffer, encode); |
|||
} |
|||
|
|||
return result; |
|||
|
|||
static string ConvertCore(HashMethod algorithm, ReadOnlySpan<byte> source, Span<byte> destination, EncodeMethod encode) |
|||
{ |
|||
var written = algorithm(source, destination); |
|||
|
|||
return encode(destination[..written]); |
|||
} |
|||
} |
|||
|
|||
public static void AppendString(this IncrementalHash hash, string value) |
|||
{ |
|||
if (string.IsNullOrWhiteSpace(value)) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
var length = Encoding.Default.GetByteCount(value); |
|||
|
|||
if (length > MaxStackSize) |
|||
{ |
|||
var buffer = ArrayPool<byte>.Shared.Rent(length); |
|||
try |
|||
{ |
|||
ConvertCore(hash, value, buffer); |
|||
} |
|||
finally |
|||
{ |
|||
ArrayPool<byte>.Shared.Return(buffer); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
Span<byte> buffer = stackalloc byte[length]; |
|||
|
|||
ConvertCore(hash, value, buffer); |
|||
} |
|||
|
|||
static void ConvertCore(IncrementalHash hash, string source, Span<byte> destination) |
|||
{ |
|||
var written = Encoding.Default.GetBytes(source, destination); |
|||
|
|||
hash.AppendData(destination[..written]); |
|||
} |
|||
} |
|||
|
|||
public static void AppendLong(this IncrementalHash hash, long version) |
|||
{ |
|||
if (version == 0) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
Span<byte> buffer = stackalloc byte[sizeof(long)]; |
|||
|
|||
if (BitConverter.TryWriteBytes(buffer, version)) |
|||
{ |
|||
hash.AppendData(buffer); |
|||
} |
|||
} |
|||
|
|||
public static string GetHexStringAndReset(this IncrementalHash hash) |
|||
{ |
|||
Span<byte> buffer = stackalloc byte[hash.HashLengthInBytes]; |
|||
|
|||
hash.GetHashAndReset(buffer); |
|||
|
|||
return ToHexString(buffer); |
|||
} |
|||
|
|||
public static string ToHexString(this ReadOnlySpan<byte> data) |
|||
{ |
|||
string result; |
|||
|
|||
var length = data.Length * 2; |
|||
|
|||
if (length > MaxStackSize) |
|||
{ |
|||
var buffer = ArrayPool<char>.Shared.Rent(length); |
|||
try |
|||
{ |
|||
result = ConvertCore(data, buffer); |
|||
} |
|||
finally |
|||
{ |
|||
ArrayPool<char>.Shared.Return(buffer); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
Span<char> buffer = stackalloc char[length]; |
|||
|
|||
result = ConvertCore(data, buffer); |
|||
} |
|||
|
|||
return result; |
|||
|
|||
static string ConvertCore(ReadOnlySpan<byte> data, Span<char> hexBuffer) |
|||
{ |
|||
unchecked |
|||
{ |
|||
int n = 0; |
|||
for (int i = 0; i < data.Length; i++) |
|||
{ |
|||
byte b = data[i]; |
|||
|
|||
byte b1 = (byte)(b >> 4); |
|||
byte b2 = (byte)(b & 0xF); |
|||
|
|||
hexBuffer[n++] = (b1 < 10) ? (char)('0' + b1) : (char)('A' + (b1 - 10)); |
|||
hexBuffer[n++] = (b2 < 10) ? (char)('0' + b2) : (char)('A' + (b2 - 10)); |
|||
} |
|||
} |
|||
|
|||
return new string(hexBuffer); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,182 @@ |
|||
// ==========================================================================
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex UG (haftungsbeschraenkt)
|
|||
// All rights reserved. Licensed under the MIT license.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Security.Cryptography; |
|||
using System.Text; |
|||
|
|||
namespace Squidex.Infrastructure; |
|||
|
|||
public class HashExtensionsTests |
|||
{ |
|||
public static IEnumerable<object[]> InputLengths() |
|||
{ |
|||
yield return new object[] { 1 }; |
|||
yield return new object[] { 20 }; |
|||
yield return new object[] { 50 }; |
|||
yield return new object[] { 500 }; |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_calculate_hex_code_from_empty_array() |
|||
{ |
|||
var source = Array.Empty<byte>(); |
|||
|
|||
var actual = ((ReadOnlySpan<byte>)source.AsSpan()).ToHexString(); |
|||
|
|||
Assert.Equal(string.Empty, actual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_calculate_hex_code_from_byte_array() |
|||
{ |
|||
var source = new byte[] { 0x00, 0x01, 0xFF, 0x1A, 0x2B, 0x3C }; |
|||
|
|||
var actual = ((ReadOnlySpan<byte>)source.AsSpan()).ToHexString(); |
|||
|
|||
Assert.Equal("0001FF1A2B3C", actual); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(InputLengths))] |
|||
public void Should_hash_md5(int length) |
|||
{ |
|||
AssertHash(HashExtensions.ToMD5, length); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(InputLengths))] |
|||
public void Should_hash_md5_from_bytes(int length) |
|||
{ |
|||
AssertHashFromBytes(HashExtensions.ToMD5, length); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(InputLengths))] |
|||
public void Should_hash_sha256(int length) |
|||
{ |
|||
AssertHash(HashExtensions.ToSha256, length); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(InputLengths))] |
|||
public void Should_hash_sha256_from_bytes(int length) |
|||
{ |
|||
AssertHashFromBytes(HashExtensions.ToSha256, length); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(InputLengths))] |
|||
public void Should_hash_sha512(int length) |
|||
{ |
|||
AssertHash(HashExtensions.ToSha512, length); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(InputLengths))] |
|||
public void Should_hash_sha512_from_bytes(int length) |
|||
{ |
|||
AssertHashFromBytes(HashExtensions.ToSha512, length); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(InputLengths))] |
|||
public void Should_hash_to_sha256_base64(int length) |
|||
{ |
|||
AssertHash(HashExtensions.ToSha256Base64, length); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(InputLengths))] |
|||
public void Should_hash_sha256_base64_from_bytes(int length) |
|||
{ |
|||
AssertHashFromBytes(HashExtensions.ToSha256Base64, length); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_convert_same_hash_as_webhook_utils() |
|||
{ |
|||
var input = $"{Guid.NewGuid()}{new string('0', 100)}{Guid.NewGuid()}"; |
|||
|
|||
var hash1 = WebhookHash(input); |
|||
var hash2 = input.ToSha256Base64(); |
|||
|
|||
Assert.Equal(hash1, hash2); |
|||
} |
|||
|
|||
private delegate string HashFromBytes(ReadOnlySpan<byte> source); |
|||
|
|||
private static void AssertHashFromBytes(HashFromBytes hasher, int length) |
|||
{ |
|||
var input1 = CreateBuffer(length, 0); |
|||
var input2 = CreateBuffer(length, 42); |
|||
|
|||
var hash1_a = hasher(input1); |
|||
var hash1_b = hasher(input1); |
|||
|
|||
var hash2 = hasher(input2); |
|||
|
|||
Assert.NotNull(hash1_a); |
|||
Assert.NotNull(hash1_a); |
|||
Assert.NotNull(hash2); |
|||
|
|||
Assert.NotEmpty(hash1_a); |
|||
Assert.NotEmpty(hash1_b); |
|||
Assert.NotEmpty(hash2); |
|||
|
|||
Assert.Equal(hash1_a, hash1_b); |
|||
|
|||
Assert.NotEqual(hash1_a, hash2); |
|||
} |
|||
|
|||
private static void AssertHash(Func<string, string> hasher, int length) |
|||
{ |
|||
var input1 = new string('a', length); |
|||
var input2 = new string('b', length); |
|||
|
|||
var hash1_a = hasher(input1); |
|||
var hash1_b = hasher(input1); |
|||
|
|||
var hash2 = hasher(input2); |
|||
|
|||
Assert.NotNull(hash1_a); |
|||
Assert.NotNull(hash1_a); |
|||
Assert.NotNull(hash2); |
|||
|
|||
Assert.NotEmpty(hash1_a); |
|||
Assert.NotEmpty(hash1_b); |
|||
Assert.NotEmpty(hash2); |
|||
|
|||
Assert.Equal(hash1_a, hash1_b); |
|||
|
|||
Assert.NotEqual(hash1_a, hash2); |
|||
} |
|||
|
|||
private static byte[] CreateBuffer(int length, int offset) |
|||
{ |
|||
var input = new byte[length]; |
|||
|
|||
for (var i = 0; i < length; i++) |
|||
{ |
|||
input[i] = (byte)(i + offset); |
|||
} |
|||
|
|||
return input; |
|||
} |
|||
|
|||
private static string WebhookHash(string value) |
|||
{ |
|||
using (var sha = SHA256.Create()) |
|||
{ |
|||
var bytesArray = Encoding.UTF8.GetBytes(value); |
|||
var bytesHash = sha.ComputeHash(bytesArray); |
|||
|
|||
var result = Convert.ToBase64String(bytesHash); |
|||
|
|||
return result; |
|||
} |
|||
} |
|||
} |
|||
@ -1,98 +0,0 @@ |
|||
// ==========================================================================
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex UG (haftungsbeschraenkt)
|
|||
// All rights reserved. Licensed under the MIT license.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Infrastructure.Reflection.Internal; |
|||
|
|||
namespace Squidex.Infrastructure.Reflection; |
|||
|
|||
public class PropertiesTypeAccessorTests |
|||
{ |
|||
public class TestClass |
|||
{ |
|||
private int target; |
|||
|
|||
public int ReadWrite |
|||
{ |
|||
get |
|||
{ |
|||
return target; |
|||
} |
|||
set |
|||
{ |
|||
target = value; |
|||
} |
|||
} |
|||
|
|||
public int Read |
|||
{ |
|||
get => target; |
|||
} |
|||
|
|||
public int Write |
|||
{ |
|||
set => target = value; |
|||
} |
|||
} |
|||
|
|||
private readonly TestClass target = new TestClass(); |
|||
|
|||
[Fact] |
|||
public void Should_set_read_write_property() |
|||
{ |
|||
var sut = new PropertyAccessor(typeof(TestClass).GetProperty("ReadWrite")!); |
|||
|
|||
sut.Set(target, 123); |
|||
|
|||
Assert.Equal(123, target.Read); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_set_write_property() |
|||
{ |
|||
var accessor = new PropertyAccessor(typeof(TestClass).GetProperty("Write")!); |
|||
|
|||
accessor.Set(target, 123); |
|||
|
|||
Assert.Equal(123, target.Read); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_setting_readonly() |
|||
{ |
|||
var sut = new PropertyAccessor(typeof(TestClass).GetProperty("Read")!); |
|||
|
|||
Assert.Throws<NotSupportedException>(() => sut.Set(target, 123)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_get_read_write_property() |
|||
{ |
|||
var sut = new PropertyAccessor(typeof(TestClass).GetProperty("ReadWrite")!); |
|||
|
|||
target.Write = 123; |
|||
|
|||
Assert.Equal(123, sut.Get(target)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_get_read_property() |
|||
{ |
|||
var sut = new PropertyAccessor(typeof(TestClass).GetProperty("Read")!); |
|||
|
|||
target.Write = 123; |
|||
|
|||
Assert.Equal(123, sut.Get(target)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_getting_writeonly_property() |
|||
{ |
|||
var sut = new PropertyAccessor(typeof(TestClass).GetProperty("Write")!); |
|||
|
|||
Assert.Throws<NotSupportedException>(() => sut.Get(target)); |
|||
} |
|||
} |
|||
@ -0,0 +1,153 @@ |
|||
// ==========================================================================
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex UG (haftungsbeschraenkt)
|
|||
// All rights reserved. Licensed under the MIT license.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Infrastructure.Reflection.Internal; |
|||
|
|||
namespace Squidex.Infrastructure.Reflection; |
|||
|
|||
public class PropertyAccessorTests |
|||
{ |
|||
public class TestClass |
|||
{ |
|||
private int readWrite; |
|||
private int readWriteVirtual; |
|||
|
|||
public int ReadWrite |
|||
{ |
|||
get |
|||
{ |
|||
return readWrite; |
|||
} |
|||
set |
|||
{ |
|||
readWrite = value; |
|||
} |
|||
} |
|||
|
|||
public virtual int ReadWriteVirtual |
|||
{ |
|||
get |
|||
{ |
|||
return readWriteVirtual; |
|||
} |
|||
set |
|||
{ |
|||
readWriteVirtual = value; |
|||
} |
|||
} |
|||
|
|||
public int ReadWriteAuto { get; set; } |
|||
|
|||
public int Read |
|||
{ |
|||
get => readWrite; |
|||
} |
|||
|
|||
public int Write |
|||
{ |
|||
set => readWrite = value; |
|||
} |
|||
} |
|||
|
|||
private readonly TestClass target = new TestClass(); |
|||
|
|||
[Fact] |
|||
public void Should_set_read_write_property() |
|||
{ |
|||
var sut = PropertyAccessor.CreateSetter<TestClass, int>(typeof(TestClass).GetProperty("ReadWrite")!); |
|||
|
|||
sut(target, 123); |
|||
|
|||
Assert.Equal(123, target.Read); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_set_virtual_read_write_property() |
|||
{ |
|||
var sut = PropertyAccessor.CreateSetter<TestClass, int>(typeof(TestClass).GetProperty("ReadWriteVirtual")!); |
|||
|
|||
sut(target, 123); |
|||
|
|||
Assert.Equal(123, target.ReadWriteVirtual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_set_auto_implemented_read_write_property() |
|||
{ |
|||
var sut = PropertyAccessor.CreateSetter<TestClass, int>(typeof(TestClass).GetProperty("ReadWriteAuto")!); |
|||
|
|||
sut(target, 123); |
|||
|
|||
Assert.Equal(123, target.ReadWriteAuto); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_set_write_property() |
|||
{ |
|||
var sut = PropertyAccessor.CreateSetter<TestClass, int>(typeof(TestClass).GetProperty("Write")!); |
|||
|
|||
sut(target, 123); |
|||
|
|||
Assert.Equal(123, target.Read); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_setting_readonly() |
|||
{ |
|||
var sut = PropertyAccessor.CreateSetter<TestClass, int>(typeof(TestClass).GetProperty("Read")!); |
|||
|
|||
Assert.Throws<NotSupportedException>(() => sut(target, 123)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_get_read_write_property() |
|||
{ |
|||
var sut = PropertyAccessor.CreateGetter<TestClass, int>(typeof(TestClass).GetProperty("ReadWrite")!); |
|||
|
|||
target.Write = 123; |
|||
|
|||
Assert.Equal(123, sut(target)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_get_virtual_read_write_property() |
|||
{ |
|||
var sut = PropertyAccessor.CreateGetter<TestClass, int>(typeof(TestClass).GetProperty("ReadWriteVirtual")!); |
|||
|
|||
target.ReadWriteVirtual = 123; |
|||
|
|||
Assert.Equal(123, sut(target)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_get_auto_implemented_read_write_property() |
|||
{ |
|||
var sut = PropertyAccessor.CreateGetter<TestClass, int>(typeof(TestClass).GetProperty("ReadWriteAuto")!); |
|||
|
|||
target.ReadWriteAuto = 123; |
|||
|
|||
Assert.Equal(123, sut(target)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_get_read_property() |
|||
{ |
|||
var sut = PropertyAccessor.CreateGetter<TestClass, int>(typeof(TestClass).GetProperty("Read")!); |
|||
|
|||
target.Write = 123; |
|||
|
|||
Assert.Equal(123, sut(target)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_getting_writeonly_property() |
|||
{ |
|||
var sut = PropertyAccessor.CreateGetter<TestClass, int>(typeof(TestClass).GetProperty("Write")!); |
|||
|
|||
Assert.Throws<NotSupportedException>(() => sut(target)); |
|||
} |
|||
} |
|||
Loading…
Reference in new issue