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)));
}
public void Init()
{
using (var stream = File.OpenWrite(this.OutputFile))
{
RawFileAccessor.Init(stream);
}
}
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 Write(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);
}
Assert.Pass();
}
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 InitVerify()
{
using (var stream = File.OpenWrite(this.OutputFile))
{
RawFileAccessor.Init(stream);
}
bool verify;
using (var stream = File.OpenRead(this.OutputFile))
{
verify = RawFileAccessor.Verify(stream);
}
Assert.That(verify);
}
public void WriteMeta()
{
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);
}
}
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");
}
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
}
