Esempio n. 1
0
        public void ReadMeta()
        {
            EllipticCurveCryptographer.CreateKeyPair(false);

            var metaInformation = new MetaInformation
            {
                PasswordDerivationSettings         = PasswordDerivationSettings.Create(),
                EllipticCurveEncryptionInformation = null,
                SecretInformationEncrypted         = Random.CreateData(1024)
            };

            using (var output = File.OpenWrite(this.OutputFile))
            {
                RawFileAccessor.WriteMeta(output, metaInformation);
            }

            MetaInformation result;

            using (var output = File.OpenRead(this.OutputFile))
            {
                result = RawFileAccessor.ReadMeta(output);
            }

            Assert.That(JsonConvert.SerializeObject(metaInformation), Is.EqualTo(JsonConvert.SerializeObject(result)));
        }
Esempio n. 2
0
        public void Workflow()
        {
            #region Arrange

            var testData = new
            {
                Iv              = Random.CreateData(RawFileAccessor.Positions[RawFileAccessor.Field.InitializationVector].length),
                Hmac            = Random.CreateData(RawFileAccessor.Positions[RawFileAccessor.Field.Hmac].length),
                Version         = Random.CreateData(RawFileAccessor.Positions[RawFileAccessor.Field.Version].length),
                Data            = Random.CreateData(1024),
                MetaInformation = new MetaInformation
                {
                    PasswordDerivationSettings         = PasswordDerivationSettings.Create(),
                    EllipticCurveEncryptionInformation = null,
                    SecretInformationEncrypted         = Random.CreateData(8)
                }
            };

            using (var stream = File.Open(this.OutputFile, FileMode.OpenOrCreate))
            {
                RawFileAccessor.Init(stream);
                RawFileAccessor.WriteMeta(stream, testData.MetaInformation);
                RawFileAccessor.SeekToMainData(stream);
                new MemoryStream(testData.Data).CopyTo(stream);
                RawFileAccessor.Write(stream, testData.Iv, RawFileAccessor.Field.InitializationVector);
                RawFileAccessor.Write(stream, testData.Hmac, RawFileAccessor.Field.Hmac);
            }

            #endregion

            #region Act

            byte[]          iv;
            byte[]          hmac;
            byte[]          data;
            MetaInformation metaInformation;
            using (var stream = File.Open(this.OutputFile, FileMode.OpenOrCreate))
            {
                metaInformation = RawFileAccessor.ReadMeta(stream);
                iv   = RawFileAccessor.Read(stream, RawFileAccessor.Field.InitializationVector);
                hmac = RawFileAccessor.Read(stream, RawFileAccessor.Field.Hmac);
                RawFileAccessor.SeekToMainData(stream);
                var ms = new MemoryStream();
                stream.CopyTo(ms);
                ;
                data = ms.ToArray();
            }

            #endregion

            #region Assert

            Assert.That(iv, Is.EquivalentTo(testData.Iv));
            Assert.That(hmac, Is.EquivalentTo(testData.Hmac));
            Assert.That(data, Is.EquivalentTo(testData.Data));

            Assert.That(JsonConvert.SerializeObject(metaInformation), Is.EquivalentTo(JsonConvert.SerializeObject(testData.MetaInformation)));

            #endregion
        }