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
}
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));
}
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
}
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));
}
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");
}
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");
}
