SharedMauiCoreLibrary/src/SharedMauiCoreLibrary.Test/CoreTests.cs at dd49b2d2ed6f3c6d53de3e4be0cc01b9b4eedf91 · AndreasReitberger/SharedMauiCoreLibrary · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
using AndreasReitberger.Shared.Core.Utilities;

namespace SharedMauiCoreLibrary.Test;

public class LicenseTests
{

    [SetUp]
    public void Setup()
    {
    }

    [Test]
    public void TestLicenseServerCommunication()
    {
        Assert.Pass();
    }

    [Test]
    public void GenerateHexStringTest()
    {
        try
        {
            int saltSize = 32;
            byte[] salt = EncryptionManager.CreateRandomSalt(saltSize);
            string hex = EncryptionManager.GetHexStringFromSalt(salt);

            using (Assert.EnterMultipleScope())
            {
                Assert.That(!string.IsNullOrEmpty(hex));
                Assert.That(hex, Has.Length.EqualTo(saltSize * 2));
            }
        }
        catch (Exception ex)
        {
            Assert.Fail(ex.Message);
        }
    }

    [Test]
    public void EncryptionTests()
    {
        try
        {
            string base64Key = EncryptionManager.GenerateBase64Key();
            Assert.That(!string.IsNullOrEmpty(base64Key));

            byte[] base64KeyBates = EncryptionManager.GetBytesFromBase64Key(base64Key);

            string plainText = "This text will be encrypted";
            string encryptedWithKey = EncryptionManager.EncryptStringToBase64String(plainText, base64Key, 256);
            Assert.That(!string.IsNullOrEmpty(encryptedWithKey));

            string decrytpedTextWithKey = EncryptionManager.DecryptStringFromBase64String(encryptedWithKey, base64Key, 256);
            Assert.That(plainText, Is.EqualTo(decrytpedTextWithKey));

            int saltSize = 16;
            string saltHexString = EncryptionManager.GetHexStringFromSalt(EncryptionManager.CreateRandomSalt(saltSize));
            Assert.That(saltHexString, Has.Length.EqualTo(saltSize * 2));
            byte[] salt = EncryptionManager.GetSaltFromHexString(saltHexString);

            string userpassword = "This is a secret text";
            byte[] hashedPassword = EncryptionManager.SaltWithPasswordString(userpassword, salt, 32);
            Assert.That(hashedPassword, Has.Length.EqualTo(32));

            string encryptedText = EncryptionManager.EncryptStringToBase64String(plainText, hashedPassword, 256);

            string decrytpedText = EncryptionManager.DecryptStringFromBase64String(encryptedText, hashedPassword, 256);
            Assert.That(plainText, Is.EqualTo(decrytpedText));

            // Recreate hash from user password
            salt = EncryptionManager.GetSaltFromHexString(saltHexString);
            hashedPassword = EncryptionManager.SaltWithPasswordString(userpassword, salt, 32);
            decrytpedText = EncryptionManager.DecryptStringFromBase64String(encryptedText, hashedPassword, 256);
            Assert.That(plainText, Is.EqualTo(decrytpedText));
        }
        catch (Exception ex)
        {

            Assert.Fail(ex.Message);
        }
    }

    [Test]
    public void UsePasswordDoubleEncryptionTest()
    {
        try
        {
            string userpassword = "Some secret password";
            byte[] hashedPassword = EncryptionManager.SaltWithPasswordString(userpassword);
            string hashedPasswordString = EncryptionManager.GetHexStringFromSalt(hashedPassword);

            string plainText = "This text will be encrypted later";
            string passphrase = EncryptionManager.GenerateBase64Key();

            string encryptedPassphrase = EncryptionManager.EncryptStringToBase64String(passphrase, hashedPassword);

            string decryptedPassphrase = EncryptionManager.DecryptStringFromBase64String(encryptedPassphrase, hashedPassword);
            Assert.That(passphrase, Is.EqualTo(decryptedPassphrase));

            var t = EncryptionManager.EncryptStringToBase64String(plainText, decryptedPassphrase);
            var t2 = EncryptionManager.DecryptStringFromBase64String(t, decryptedPassphrase);

            Assert.That(plainText, Is.EqualTo(t2));
        }
        catch (Exception ex)
        {
            Assert.Fail(ex.Message);
        }
    }
}