示例#1
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
        }
        public void FileformatHelper_MemoryStream()
        {
            #region Arrange

            var secret = Encryption.Random.CreateData(512 / 8);
            var data   = Guid.NewGuid().ToByteArray();

            #endregion

            #region Act

            byte[] encryptedData = null;
            using (var input = new MemoryStream(data))
                using (var output = new MemoryStream())
                {
                    SymmetricEncryption.EncryptInternal(input, output, secret);
                    encryptedData = output.ToArray();
                }

            Console.Out.WriteLine("Encrypted content: " + Convert.ToBase64String(File.ReadAllBytes(this.OutputFile)));

            byte[] iv;
            byte[] hmac;
            using (var input = new MemoryStream(encryptedData))
            {
                iv   = RawFileAccessor.Read(input, RawFileAccessor.Field.InitializationVector);
                hmac = RawFileAccessor.Read(input, RawFileAccessor.Field.Hmac);
            }

            #endregion

            #region Assert

            Assert.That(iv, Is.Not.Null);
            Assert.That(hmac, Is.Not.Null);

            Assert.That(iv, Has.Length.EqualTo(128 / 8));
            Assert.That(hmac, Has.Length.EqualTo(512 / 8));

            Assert.That(iv, Has.Some.Not.EqualTo(0));
            Assert.That(hmac, Has.Some.Not.EqualTo(0));

            #endregion
        }
示例#3
0
        public void SeekToMainDataWithData()
        {
            using (var stream = File.OpenWrite(this.OutputFile))
            {
                foreach (var value in RawFileAccessor.Positions.Keys)
                {
                    var inputData = Random.CreateData(RawFileAccessor.Positions[value].length);
                    RawFileAccessor.Write(stream, inputData, value);
                }
            }
            var metaInformation = new MetaInformation
            {
                PasswordDerivationSettings         = PasswordDerivationSettings.Create(),
                EllipticCurveEncryptionInformation = null,
                SecretInformationEncrypted         = Random.CreateData(1024)
            };

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

            int metaPosition = 0;

            using (var output = File.OpenRead(this.OutputFile))
            {
                var data = RawFileAccessor.Read(output, RawFileAccessor.Field.MetaLength);
                metaPosition = BitConverter.ToInt32(data, 0);
            }


            long position = 0;

            using (var stream = File.OpenRead(this.OutputFile))
            {
                RawFileAccessor.SeekToMainData(stream);
                position = stream.Position;
            }

            var sum = RawFileAccessor.Positions.Sum(pair => pair.Value.length);

            Assert.That(position, Is.EqualTo(sum + metaPosition));
        }
示例#4
0
        public void Read_FileStream(string name)
        {
            var field = (RawFileAccessor.Field)Enum.Parse(typeof(RawFileAccessor.Field), name);

            var inputData = Random.CreateData(RawFileAccessor.Positions[field].length);

            using (var stream = File.OpenWrite(this.OutputFile))
            {
                RawFileAccessor.Write(stream, inputData, field);
            }


            byte[] readData;
            using (var stream = File.OpenRead(this.OutputFile))
            {
                readData = RawFileAccessor.Read(stream, field);
            }

            Assert.That(inputData, Is.EquivalentTo(readData));
        }
        public void FileformatHelper_FileStream()
        {
            #region Arrange

            var secret = Encryption.Random.CreateData(512 / 8);

            #endregion

            #region Act

            using (var input = File.OpenRead(this.InputFile))
                using (var output = File.Open(this.OutputFile, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
                {
                    SymmetricEncryption.EncryptInternal(input, output, secret);
                }

            Console.Out.WriteLine("Encrypted content: " + Convert.ToBase64String(File.ReadAllBytes(this.OutputFile)));

            byte[] iv;
            byte[] hmac;
            using (var input = File.OpenRead(this.OutputFile))
            {
                iv   = RawFileAccessor.Read(input, RawFileAccessor.Field.InitializationVector);
                hmac = RawFileAccessor.Read(input, RawFileAccessor.Field.Hmac);
            }

            #endregion

            #region Assert

            Assert.That(iv, Is.Not.Null);
            Assert.That(hmac, Is.Not.Null);

            Assert.That(iv, Has.Length.EqualTo(128 / 8));
            Assert.That(hmac, Has.Length.EqualTo(512 / 8));

            Assert.That(iv, Has.Some.Not.EqualTo(0));
            Assert.That(hmac, Has.Some.Not.EqualTo(0));

            #endregion
        }
示例#6
0
        public void Read_MemoryStream(string name)
        {
            var field = (RawFileAccessor.Field)Enum.Parse(typeof(RawFileAccessor.Field), name);

            var          inputData = Random.CreateData(RawFileAccessor.Positions[field].length);
            MemoryStream inputStream;

            using (inputStream = new MemoryStream())
            {
                RawFileAccessor.Write(inputStream, inputData, field);
            }


            byte[] readData;
            using (var stream = new MemoryStream(inputStream.ToArray()))
            {
                readData = RawFileAccessor.Read(stream, field);
            }

            Assert.That(inputData, Is.EquivalentTo(readData));
        }
示例#7
0
        public void EncryptInternal_FileStream()
        {
            var data   = Guid.NewGuid().ToByteArray();
            var secret = Random.CreateData(512 / 8);

            using (var output = File.Open(this.OutputFile, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
            {
                SymmetricEncryption.EncryptInternal(new MemoryStream(data), output, secret);
            }

            var newStream = File.OpenRead(this.OutputFile);

            Assert.That(RawFileAccessor.Verify(newStream));

            var iv = RawFileAccessor.Read(newStream, RawFileAccessor.Field.InitializationVector);

            Assert.That(iv, Has.Some.Not.EqualTo(0), "InitializationVector");

            var hmac = RawFileAccessor.Read(newStream, RawFileAccessor.Field.Hmac);

            Assert.That(hmac, Has.Some.Not.EqualTo(0), "Hmac");
        }
示例#8
0
        public void EncryptInternal_MemoryStream()
        {
            var data   = Guid.NewGuid().ToByteArray();
            var secret = Random.CreateData(512 / 8);

            MemoryStream newStream;

            using (var encrypted = new MemoryStream())
            {
                SymmetricEncryption.EncryptInternal(new MemoryStream(data), encrypted, secret);
                newStream = new MemoryStream(encrypted.ToArray());
            }

            Assert.That(RawFileAccessor.Verify(newStream), "verify file signature");

            var iv = RawFileAccessor.Read(newStream, RawFileAccessor.Field.InitializationVector);

            Assert.That(iv, Has.Some.Not.EqualTo(0), "InitializationVector");

            var hmac = RawFileAccessor.Read(newStream, RawFileAccessor.Field.Hmac);

            Assert.That(hmac, Has.Some.Not.EqualTo(0), "Hmac");
        }