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

44
ModernKeePassLib.Test/Cryptography/Cipher/AesTests.cs
View File

@@ -1,16 +1,15 @@
using System.IO;
using System.Security.Cryptography;
using System.Text;
using NUnit.Framework;
using ModernKeePassLib.Serialization;
using ModernKeePassLib.Cryptography;
using ModernKeePassLib.Cryptography.Cipher;
using ModernKeePassLib.Utility;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Parameters;
using Xunit;
using System.Security.Cryptography;
using ModernKeePassLib.Cryptography;
namespace ModernKeePassLib.Test.Cryptography.Cipher
{
[TestFixture]
public class AesTests
{
// Test vector (official ECB test vector #356)
@@ -27,7 +26,7 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
[Fact]
[Test]
public void TestEncryptStream()
{
var a = CryptoUtil.CreateAes();
@@ -45,35 +44,20 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
iCrypt.TransformBlock(_pbTestData, 0, 16, _pbTestData, 0);
Assert.True(MemUtil.ArraysEqual(_pbTestData, _pbReferenceCt));
Assert.That(MemUtil.ArraysEqual(_pbTestData, _pbReferenceCt), Is.True);
}
[Fact]
[Test]
public void TestDecryptStream()
{
// Possible Mono Bug? This only works with size >= 48
using (var inStream = new MemoryStream(new byte[32]))
{
inStream.Write(_pbReferenceCt, 0, _pbReferenceCt.Length);
inStream.Position = 0;
var aes = new StandardAesEngine();
using (var outStream = aes.DecryptStream(inStream, _pbTestKey, _pbIv))
{
var outBytes = new BinaryReaderEx(outStream, Encoding.UTF8, string.Empty).ReadBytes(16);
Assert.True(MemUtil.ArraysEqual(outBytes, _pbTestData));
}
}
}
[Fact]
public void TestBouncyCastleAes()
{
var aesEngine = new AesEngine();
//var parametersWithIv = new ParametersWithIV(new KeyParameter(pbTestKey), pbIV);
aesEngine.Init(true, new KeyParameter(_pbTestKey));
Assert.Equal(_pbTestData.Length, aesEngine.GetBlockSize());
aesEngine.ProcessBlock(_pbTestData, 0, _pbTestData, 0);
Assert.True(MemUtil.ArraysEqual(_pbReferenceCt,_pbTestData));
using var inStream = new MemoryStream(new byte[32]);
inStream.Write(_pbReferenceCt, 0, _pbReferenceCt.Length);
inStream.Position = 0;
var aes = new StandardAesEngine();
using var outStream = aes.DecryptStream(inStream, _pbTestKey, _pbIv);
var outBytes = new BinaryReaderEx(outStream, Encoding.UTF8, string.Empty).ReadBytes(16);
Assert.That(MemUtil.ArraysEqual(outBytes, _pbTestData), Is.True);
}
}
}

62
ModernKeePassLib.Test/Cryptography/Cipher/Chacha20Tests.cs
View File

@@ -4,13 +4,14 @@ using System.IO;
using ModernKeePassLib.Cryptography;
using ModernKeePassLib.Cryptography.Cipher;
using ModernKeePassLib.Utility;
using Xunit;
using NUnit.Framework;
namespace ModernKeePassLib.Test.Cryptography.Cipher
{
[TestFixture]
public class Chacha20Tests
{
[Fact]
[Test]
public void TestChacha20Cipher()
{
// ======================================================
@@ -23,7 +24,7 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
pbIV[3] = 0x09;
pbIV[7] = 0x4A;
var pbExpc = new byte[64] {
var pbExpc = new byte[] {
0x10, 0xF1, 0xE7, 0xE4, 0xD1, 0x3B, 0x59, 0x15,
0x50, 0x0F, 0xDD, 0x1F, 0xA3, 0x20, 0x71, 0xC4,
0xC7, 0xD1, 0xF4, 0xC7, 0x33, 0xC0, 0x68, 0x03,
@@ -36,12 +37,12 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
var pb = new byte[64];
using (var c = new ChaCha20Cipher(pbKey, pbIV))
using (var chaCha20Cipher1 = new ChaCha20Cipher(pbKey, pbIV))
{
c.Seek(64, SeekOrigin.Begin); // Skip first block
c.Encrypt(pb, 0, pb.Length);
chaCha20Cipher1.Seek(64, SeekOrigin.Begin); // Skip first block
chaCha20Cipher1.Encrypt(pb, 0, pb.Length);
Assert.True(MemUtil.ArraysEqual(pb, pbExpc));
Assert.That(MemUtil.ArraysEqual(pb, pbExpc), Is.True);
}
#if DEBUG
@@ -74,12 +75,12 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
var pb64 = new byte[64];
using (var c = new ChaCha20Cipher(pbKey, pbIV))
using (var chaCha20Cipher2 = new ChaCha20Cipher(pbKey, pbIV))
{
c.Encrypt(pb64, 0, pb64.Length); // Skip first block
c.Encrypt(pb, 0, pb.Length);
chaCha20Cipher2.Encrypt(pb64, 0, pb64.Length); // Skip first block
chaCha20Cipher2.Encrypt(pb, 0, pb.Length);
Assert.True(MemUtil.ArraysEqual(pb, pbExpc));
Assert.That(MemUtil.ArraysEqual(pb, pbExpc), Is.True);
}
// ======================================================
@@ -116,17 +117,17 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
using (var msEnc = new MemoryStream())
{
using (var c = new ChaCha20Stream(msEnc, true, pbKey, pbIV))
using (var chaCha20Stream = new ChaCha20Stream(msEnc, true, pbKey, pbIV))
{
var r = CryptoRandom.NewWeakRandom();
r.NextBytes(pb64);
c.Write(pb64, 0, pb64.Length); // Skip first block
chaCha20Stream.Write(pb64, 0, pb64.Length); // Skip first block
var p = 0;
while (p < pb.Length)
{
var cb = r.Next(1, pb.Length - p + 1);
c.Write(pb, p, cb);
chaCha20Stream.Write(pb, p, cb);
p += cb;
}
Debug.Assert(p == pb.Length);
@@ -134,27 +135,22 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
var pbEnc0 = msEnc.ToArray();
var pbEnc = MemUtil.Mid(pbEnc0, 64, pbEnc0.Length - 64);
Assert.True(MemUtil.ArraysEqual(pbEnc, pbExpc));
Assert.That(MemUtil.ArraysEqual(pbEnc, pbExpc), Is.True);
using (var msCT = new MemoryStream(pbEnc0, false))
{
using (var cDec = new ChaCha20Stream(msCT, false,
pbKey, pbIV))
{
var pbPT = MemUtil.Read(cDec, pbEnc0.Length);
using var msCT = new MemoryStream(pbEnc0, false);
using var cDec = new ChaCha20Stream(msCT, false, pbKey, pbIV);
var pbPT = MemUtil.Read(cDec, pbEnc0.Length);
Assert.True(cDec.ReadByte() < 0);
Assert.True(MemUtil.ArraysEqual(MemUtil.Mid(pbPT, 0, 64), pb64));
Assert.True(MemUtil.ArraysEqual(MemUtil.Mid(pbPT, 64, pbEnc.Length), pb));
}
}
Assert.That(cDec.ReadByte(), Is.LessThan(0));
Assert.That(MemUtil.ArraysEqual(MemUtil.Mid(pbPT, 0, 64), pb64), Is.True);
Assert.That(MemUtil.ArraysEqual(MemUtil.Mid(pbPT, 64, pbEnc.Length), pb), Is.True);
}
// ======================================================
// Test vector TC8 from RFC draft by J. Strombergson:
// https://tools.ietf.org/html/draft-strombergson-chacha-test-vectors-01
pbKey = new byte[32] {
pbKey = new byte[] {
0xC4, 0x6E, 0xC1, 0xB1, 0x8C, 0xE8, 0xA8, 0x78,
0x72, 0x5A, 0x37, 0xE7, 0x80, 0xDF, 0xB7, 0x35,
0x1F, 0x68, 0xED, 0x2E, 0x19, 0x4C, 0x79, 0xFB,
@@ -165,13 +161,13 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
// is used; this makes the RFC 7539 version of ChaCha20
// compatible with the original specification by
// D. J. Bernstein.
pbIV = new byte[12] { 0x00, 0x00, 0x00, 0x00,
pbIV = new byte[] { 0x00, 0x00, 0x00, 0x00,
0x1A, 0xDA, 0x31, 0xD5, 0xCF, 0x68, 0x82, 0x21
};
pb = new byte[128];
pbExpc = new byte[128] {
pbExpc = new byte[] {
0xF6, 0x3A, 0x89, 0xB7, 0x5C, 0x22, 0x71, 0xF9,
0x36, 0x88, 0x16, 0x54, 0x2B, 0xA5, 0x2F, 0x06,
0xED, 0x49, 0x24, 0x17, 0x92, 0x30, 0x2B, 0x00,
@@ -191,12 +187,10 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
0x05, 0x3C, 0x84, 0xE4, 0x9A, 0x4A, 0x33, 0x32
};
using (var c = new ChaCha20Cipher(pbKey, pbIV, true))
{
c.Decrypt(pb, 0, pb.Length);
using var c = new ChaCha20Cipher(pbKey, pbIV, true);
c.Decrypt(pb, 0, pb.Length);
Assert.True(MemUtil.ArraysEqual(pb, pbExpc));
}
Assert.That(MemUtil.ArraysEqual(pb, pbExpc), Is.True);
#endif
}
}

13
ModernKeePassLib.Test/Cryptography/Cipher/Salsa20Tests.cs
View File

@@ -3,13 +3,14 @@ using System.Collections.Generic;
using ModernKeePassLib.Cryptography;
using ModernKeePassLib.Cryptography.Cipher;
using ModernKeePassLib.Utility;
using Xunit;
using NUnit.Framework;
namespace ModernKeePassLib.Test.Cryptography.Cipher
{
[TestFixture]
public class Salsa20Tests
{
[Fact]
[Test]
public void TestSalsa20Cipher()
{
var r = CryptoRandom.NewWeakRandom();
@@ -31,7 +32,7 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
var pb = new byte[16];
var c = new Salsa20Cipher(pbKey, pbIv);
c.Encrypt(pb, 0, pb.Length);
Assert.True(MemUtil.ArraysEqual(pb, pbExpected));
Assert.That(MemUtil.ArraysEqual(pb, pbExpected), Is.True);
// Extended test
var pbExpected2 = new byte[] {
@@ -46,12 +47,12 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
var nPos = Salsa20ToPos(c, r, pb.Length, 65536);
Array.Clear(pb, 0, pb.Length);
c.Encrypt(pb, 0, pb.Length);
Assert.True(MemUtil.ArraysEqual(pb, pbExpected2));
Assert.That(MemUtil.ArraysEqual(pb, pbExpected2), Is.True);
Salsa20ToPos(c, r, nPos + pb.Length, 131008);
Array.Clear(pb, 0, pb.Length);
c.Encrypt(pb, 0, pb.Length);
Assert.True(MemUtil.ArraysEqual(pb, pbExpected3));
Assert.That(MemUtil.ArraysEqual(pb, pbExpected3), Is.True);
var d = new Dictionary<string, bool>();
const int nRounds = 100;
@@ -62,7 +63,7 @@ namespace ModernKeePassLib.Test.Cryptography.Cipher
c.Encrypt(z, 0, z.Length);
d[MemUtil.ByteArrayToHexString(z)] = true;
}
Assert.Equal(nRounds, d.Count);
Assert.That(d.Count, Is.EqualTo(nRounds));
}
private static int Salsa20ToPos(Salsa20Cipher c, Random r, int nPos,