devolutions-crypto 0.9.2

An abstraction layer for the cryptography used by Devolutions
Documentation 
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

#pragma warning disable SA1600 // Elements should be documented

namespace Devolutions.Crypto.Tests
{
    using System;
    using System.IO;

    using Devolutions.Cryptography.Argon2;

    using Microsoft.VisualStudio.TestTools.UnitTesting;

    [TestClass]
    public class TestArgon2Parameters
    {
        [TestMethod]
        public void FromByteArray()
        {
            Argon2Parameters parameters = Argon2Parameters.FromByteArray(Convert.FromBase64String(TestData.Argon2DefaultParametersb64));
            Assert.IsTrue(parameters.Iterations == 2);
            Assert.IsTrue(parameters.Lanes == 1);
            Assert.IsTrue(parameters.Length == 32);
            Assert.IsTrue(parameters.Memory == 4096);
        }

        [TestMethod]
        public void ToByteArray()
        {
            Argon2Parameters parameters = new Argon2Parameters();
            parameters.Memory = 4096;

            byte[] result = parameters.ToByteArray();

            Assert.IsTrue(result != null);

            Assert.IsTrue(result.Length == Argon2Parameters.NativeSize);

            MemoryStream stream = new MemoryStream(result);

            // ==== Devolutions Crypto Version ====
            byte[] buffer = new byte[4];

            stream.Read(buffer, 0, 4);

            if (!BitConverter.IsLittleEndian)
            {
                Array.Reverse(buffer);
            }

            Assert.IsTrue(BitConverter.ToUInt32(buffer, 0) == 1);

            // ==== Length ====
            stream.Read(buffer, 0, 4);

            if (!BitConverter.IsLittleEndian)
            {
                Array.Reverse(buffer);
            }

            Assert.IsTrue(BitConverter.ToUInt32(buffer, 0) == 32);

            // ==== Lanes ====
            stream.Read(buffer, 0, 4);

            if (!BitConverter.IsLittleEndian)
            {
                Array.Reverse(buffer);
            }

            Assert.IsTrue(BitConverter.ToUInt32(buffer, 0) == 1);

            // ==== Memory ====
            stream.Read(buffer, 0, 4);

            if (!BitConverter.IsLittleEndian)
            {
                Array.Reverse(buffer);
            }

            Assert.IsTrue(BitConverter.ToUInt32(buffer, 0) == 4096);

            // ==== Iterations ====
            stream.Read(buffer, 0, 4);

            if (!BitConverter.IsLittleEndian)
            {
                Array.Reverse(buffer);
            }

            Assert.IsTrue(BitConverter.ToUInt32(buffer, 0) == 2);

            // ==== Variant ====
            stream.Read(buffer, 0, 1);

            Assert.IsTrue((Variant)buffer[0] == Variant.Argon2id);

            // ==== Version ====
            stream.Read(buffer, 0, 1);

            Assert.IsTrue((Devolutions.Cryptography.Argon2.Version)buffer[0] == Devolutions.Cryptography.Argon2.Version.Version13);
        }
    }
}
#pragma warning restore SA1600 // Elements should be documented