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 SeekToMainData()
{
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));
}
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 EncryptAndDecrypt_Filepath_Test(EncryptionSecret secretType, bool withFilename)
{
#region Arrange
var data = Random.CreateData(128 / 8);
File.WriteAllBytes(this.InputFile, data);
var pwd = Guid.NewGuid().ToString();
var filename = Guid.NewGuid().ToString();
var key = Random.CreateData(512 / 8);
#endregion
#region Act
switch (secretType)
{
case EncryptionSecret.Password:
if (withFilename)
{
SymmetricEncryption.Encrypt(this.InputFile, this.OutputFile, pwd, filename);
}
else
{
SymmetricEncryption.Encrypt(this.InputFile, this.OutputFile, pwd);
}
break;
case EncryptionSecret.Key:
if (withFilename)
{
SymmetricEncryption.Encrypt(this.InputFile, this.OutputFile, key, filename);
}
else
{
SymmetricEncryption.Encrypt(this.InputFile, this.OutputFile, key);
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(secretType), secretType, null);
}
byte[] dataContent;
using (var stream = File.OpenRead(this.OutputFile))
{
RawFileAccessor.SeekToMainData(stream);
var ms = new MemoryStream();
stream.CopyTo(ms);
dataContent = ms.ToArray();
}
Console.Out.WriteLine("Encrypted Content: " + Convert.ToBase64String(dataContent));
DecryptInfo info;
using (var input = File.OpenRead(this.OutputFile))
using (var output = File.Create(this.ResultFile))
{
switch (secretType)
{
case EncryptionSecret.Password:
info = SymmetricEncryption.Decrypt(input, output, pwd);
break;
case EncryptionSecret.Key:
info = SymmetricEncryption.Decrypt(input, output, key);
break;
default:
throw new ArgumentOutOfRangeException(nameof(secretType), secretType, null);
}
}
#endregion
#region Assert
if (withFilename)
{
Assert.That(info?.FileName, Is.EqualTo(filename), "Filename is correct decrypted.");
}
else
{
Assert.That(info.FileName, Is.Null, "Filename should be Null.");
}
Assert.That(data, Is.Not.EquivalentTo(File.ReadAllBytes(this.OutputFile)));
Assert.That(data.Length, Is.LessThan(File.ReadAllBytes(this.OutputFile).Length));
Assert.That(FileOperation.HasFileSignature(this.OutputFile), "HasFileSignature");
Assert.That(File.ReadAllBytes(this.ResultFile), Is.EquivalentTo(data), "Plaindata is equal after decryption");
#endregion
}
