wismna/modernkeepasslib
1
0
Fork 0
mirror of https://github.com/wismna/ModernKeePassLib.git synced 2025-10-03 23:50:20 -04:00
Code Issues Packages Projects Releases Wiki Activity

Removed useless Bouncy Castle package and test

Browse Source 
Migrated to Nunit
Refactor
This commit is contained in:
Geoffroy BONNEVILLE
2019-07-29 17:30:15 +02:00
parent 26e8e5c223
commit c4de2dd594
23 changed files with 381 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
ModernKeePassLib.Test/Cryptography/Hash/Blake2bTests.cs
View File

@@ -1,24 +1,36 @@
using System;
using System.Text;
using System.Text;
using ModernKeePassLib.Cryptography;
using ModernKeePassLib.Cryptography.Hash;
using ModernKeePassLib.Utility;
using Xunit;
using NUnit.Framework;
namespace ModernKeePassLib.Test.Cryptography.Hash
{
[TestFixture]
public class Blake2bTests
{
[Fact]
private Blake2b _blake2bHash;
[SetUp]
public void SetUp()
{
_blake2bHash = new Blake2b();
}
[TearDown]
public void TearDown()
{
_blake2bHash.Clear();
}
[Test]
public void TestBlake2bUtf8()
{
Blake2b h = new Blake2b();
// ======================================================
// From https://tools.ietf.org/html/rfc7693
byte[] pbData = StrUtil.Utf8.GetBytes("abc");
byte[] pbExpc = new byte[64]
var pbData = StrUtil.Utf8.GetBytes("abc");
var pbExpc = new byte[]
{
0xBA, 0x80, 0xA5, 0x3F, 0x98, 0x1C, 0x4D, 0x0D,
0x6A, 0x27, 0x97, 0xB6, 0x9F, 0x12, 0xF6, 0xE9,
@@ -30,18 +42,17 @@ namespace ModernKeePassLib.Test.Cryptography.Hash
0xB9, 0x23, 0x86, 0xED, 0xD4, 0x00, 0x99, 0x23
};
byte[] pbC = h.ComputeHash(pbData);
Assert.True(MemUtil.ArraysEqual(pbC, pbExpc));
var pbC = _blake2bHash.ComputeHash(pbData);
Assert.That(MemUtil.ArraysEqual(pbC, pbExpc), Is.True);
}
[Fact]
[Test]
public void TestBlake2bEmpty()
{
// ======================================================
// Computed using the official b2sum tool
Blake2b h = new Blake2b();
var pbExpc = new byte[64]
var pbExpc = new byte[]
{
0x78, 0x6A, 0x02, 0xF7, 0x42, 0x01, 0x59, 0x03,
0xC6, 0xC6, 0xFD, 0x85, 0x25, 0x52, 0xD2, 0x72,
@@ -53,23 +64,22 @@ namespace ModernKeePassLib.Test.Cryptography.Hash
0xD5, 0x6F, 0x70, 0x1A, 0xFE, 0x9B, 0xE2, 0xCE
};
var pbC = h.ComputeHash(new byte[0]);
Assert.True(MemUtil.ArraysEqual(pbC, pbExpc));
var pbC = _blake2bHash.ComputeHash(new byte[0]);
Assert.That(MemUtil.ArraysEqual(pbC, pbExpc), Is.True);
}
[Fact]
[Test]
public void TestBlake2bString()
{
// ======================================================
// Computed using the official b2sum tool
Blake2b h = new Blake2b();
string strS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.:,;_-\r\n";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; ++i) sb.Append(strS);
var strS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.:,;_-\r\n";
var sb = new StringBuilder();
for (var i = 0; i < 1000; ++i) sb.Append(strS);
var pbData = StrUtil.Utf8.GetBytes(sb.ToString());
var pbExpc = new byte[64] {
var pbExpc = new byte[] {
0x59, 0x69, 0x8D, 0x3B, 0x83, 0xF4, 0x02, 0x4E,
0xD8, 0x99, 0x26, 0x0E, 0xF4, 0xE5, 0x9F, 0x20,
0xDC, 0x31, 0xEE, 0x5B, 0x45, 0xEA, 0xBB, 0xFC,
@@ -80,21 +90,19 @@ namespace ModernKeePassLib.Test.Cryptography.Hash
0x3F, 0x08, 0x8A, 0x93, 0xF8, 0x75, 0x91, 0xB0
};
Random r = CryptoRandom.NewWeakRandom();
int p = 0;
var r = CryptoRandom.NewWeakRandom();
var p = 0;
while (p < pbData.Length)
{
int cb = r.Next(1, pbData.Length - p + 1);
h.TransformBlock(pbData, p, cb, pbData, p);
var cb = r.Next(1, pbData.Length - p + 1);
_blake2bHash.TransformBlock(pbData, p, cb, pbData, p);
p += cb;
}
Assert.Equal(p, pbData.Length);
Assert.That(p, Is.EqualTo(pbData.Length));
h.TransformFinalBlock(new byte[0], 0, 0);
_blake2bHash.TransformFinalBlock(new byte[0], 0, 0);
Assert.True(MemUtil.ArraysEqual(h.Hash, pbExpc));
h.Clear();
Assert.That(MemUtil.ArraysEqual(_blake2bHash.Hash, pbExpc), Is.True);
}
}
}

81
ModernKeePassLib.Test/Cryptography/Hash/HmacTests.cs
View File

@@ -1,13 +1,15 @@
using ModernKeePassLib.Cryptography;
using System.Linq;
using ModernKeePassLib.Cryptography;
using ModernKeePassLib.Utility;
using System.Security.Cryptography;
using Xunit;
using NUnit.Framework;
namespace ModernKeePassLib.Test.Cryptography.Hash
{
[TestFixture]
public class HmacTests
{
[Fact]
[Test]
public void TestHmac1()
{
// Test vectors from RFC 4231
@@ -25,7 +27,7 @@ namespace ModernKeePassLib.Test.Cryptography.Hash
HmacEval(pbKey, pbMsg, pbExpc);
}
[Fact]
[Test]
public void TestHmac2()
{
var pbKey = new byte[131];
@@ -43,74 +45,65 @@ namespace ModernKeePassLib.Test.Cryptography.Hash
HmacEval(pbKey, pbMsg, pbExpc);
}
[Fact]
[Test]
public void TestHmacSha1ComputeHash()
{
var expectedHash = "AC2C2E614882CE7158F69B7E3B12114465945D01";
var message = StrUtil.Utf8.GetBytes("testing123");
var key = StrUtil.Utf8.GetBytes("hello");
using (var result = new HMACSHA1(key))
{
Assert.Equal(ByteToString(result.ComputeHash(message)), expectedHash);
}
using var result = new HMACSHA1(key);
Assert.That(expectedHash, Is.EqualTo(ByteToString(result.ComputeHash(message))));
}
[Fact]
[Test]
public void TestHmacSha256ComputeHash()
{
var expectedHash = "09C1BD2DE4E5659C0EFAF9E6AE4723E9CF96B69609B4E562F6AFF1745D7BF4E0";
var message = StrUtil.Utf8.GetBytes("testing123");
var key = StrUtil.Utf8.GetBytes("hello");
using (var result = new HMACSHA256(key))
{
Assert.Equal(ByteToString(result.ComputeHash(message)), expectedHash);
}
using var result = new HMACSHA256(key);
Assert.That(expectedHash, Is.EqualTo(ByteToString(result.ComputeHash(message))));
}
private static string ByteToString(byte[] buff)
{
string sbinary = "";
for (int i = 0; i < buff.Length; i++)
{
sbinary += buff[i].ToString("X2"); // hex format
}
return (sbinary);
return buff.Aggregate("", (current, t) => current + t.ToString("X2"));
}
[Fact]
public void TestHmacOtp()
[Test]
[TestCase(0, ExpectedResult = "755224")]
[TestCase(1, ExpectedResult = "287082")]
[TestCase(2, ExpectedResult = "359152")]
[TestCase(3, ExpectedResult = "969429")]
[TestCase(4, ExpectedResult = "338314")]
[TestCase(5, ExpectedResult = "254676")]
[TestCase(6, ExpectedResult = "287922")]
[TestCase(7, ExpectedResult = "162583")]
[TestCase(8, ExpectedResult = "399871")]
[TestCase(9, ExpectedResult = "520489")]
public string TestHmacOtp(int factor)
{
var pbSecret = StrUtil.Utf8.GetBytes("12345678901234567890");
var vExp = new []{ "755224", "287082", "359152",
"969429", "338314", "254676", "287922", "162583", "399871",
"520489" };
for (var i = 0; i < vExp.Length; ++i)
{
Assert.Equal(HmacOtp.Generate(pbSecret, (ulong)i, 6, false, -1), vExp[i]);
}
return HmacOtp.Generate(pbSecret, (ulong)factor, 6, false, -1);
}
private static void HmacEval(byte[] pbKey, byte[] pbMsg,
byte[] pbExpc)
{
using (var h = new HMACSHA256(pbKey))
{
h.TransformBlock(pbMsg, 0, pbMsg.Length, pbMsg, 0);
h.TransformFinalBlock(new byte[0], 0, 0);
using var h = new HMACSHA256(pbKey);
h.TransformBlock(pbMsg, 0, pbMsg.Length, pbMsg, 0);
h.TransformFinalBlock(new byte[0], 0, 0);
byte[] pbHash = h.Hash;
Assert.True(MemUtil.ArraysEqual(pbHash, pbExpc));
var pbHash = h.Hash;
Assert.That(MemUtil.ArraysEqual(pbHash, pbExpc), Is.True);
// Reuse the object
h.Initialize();
h.TransformBlock(pbMsg, 0, pbMsg.Length, pbMsg, 0);
h.TransformFinalBlock(new byte[0], 0, 0);
// Reuse the object
h.Initialize();
h.TransformBlock(pbMsg, 0, pbMsg.Length, pbMsg, 0);
h.TransformFinalBlock(new byte[0], 0, 0);
pbHash = h.Hash;
Assert.True(MemUtil.ArraysEqual(pbHash, pbExpc));
}
pbHash = h.Hash;
Assert.That(MemUtil.ArraysEqual(pbHash, pbExpc), Is.True);
}
}
}

32
ModernKeePassLib.Test/Cryptography/Hash/SHAManagedTests.cs
View File

@@ -1,13 +1,15 @@
using ModernKeePassLib.Utility;
using System.Linq;
using ModernKeePassLib.Utility;
using System.Security.Cryptography;
using ModernKeePassLib.Cryptography;
using Xunit;
using NUnit.Framework;
namespace ModernKeePassLib.Test.Cryptography.Hash
{
[TestFixture]
public class ShaManagedTests
{
[Fact]
[Test]
public void TestSha256()
{
var r = CryptoRandom.NewWeakRandom();
@@ -34,39 +36,31 @@ namespace ModernKeePassLib.Test.Cryptography.Hash
pbH2 = h2.ComputeHash(pbData);
}
Assert.True(MemUtil.ArraysEqual(pbH1, pbH2));
Assert.That(MemUtil.ArraysEqual(pbH1, pbH2), Is.True);
}
[Fact]
[Test]
public void TestSha256ComputeHash()
{
var expectedHash = "B822F1CD2DCFC685B47E83E3980289FD5D8E3FF3A82DEF24D7D1D68BB272EB32";
var message = StrUtil.Utf8.GetBytes("testing123");
using (var result = new SHA256Managed())
{
Assert.Equal(ByteToString(result.ComputeHash(message)), expectedHash);
}
using var result = new SHA256Managed();
Assert.That(expectedHash, Is.EqualTo(ByteToString(result.ComputeHash(message))));
}
[Fact]
[Test]
public void TestSha512ComputeHash()
{
var expectedHash = "4120117B3190BA5E24044732B0B09AA9ED50EB1567705ABCBFA78431A4E0A96B1152ED7F4925966B1C82325E186A8100E692E6D2FCB6702572765820D25C7E9E";
var message = StrUtil.Utf8.GetBytes("testing123");
using (var result = new SHA512Managed())
{
Assert.Equal(ByteToString(result.ComputeHash(message)), expectedHash);
}
using var result = new SHA512Managed();
Assert.That(expectedHash, Is.EqualTo(ByteToString(result.ComputeHash(message))));
}
private static string ByteToString(byte[] buff)
{
var sbinary = "";
var sbinary = buff.Aggregate("", (current, t) => current + t.ToString("X2"));
for (var i = 0; i < buff.Length; i++)
{
sbinary += buff[i].ToString("X2"); // hex format
}
return (sbinary);
}
}