public void TestDocumentHeaderProperties()
{
using (MemoryStream inputStream = new MemoryStream())
{
byte[] text = Resolve.RandomGenerator.Generate(500);
inputStream.Write(text, 0, text.Length);
inputStream.Position = 0;
byte[] buffer = new byte[3000];
using (IAxCryptDocument document = new V2AxCryptDocument(new EncryptionParameters(new V2Aes256CryptoFactory().CryptoId, new Passphrase("properties")), 15))
{
DateTime utcNow = New <INow>().Utc;
DateTime lastWrite = utcNow.AddHours(1);
DateTime lastAccess = utcNow.AddHours(2);
DateTime create = utcNow.AddHours(3);
document.CreationTimeUtc = create;
document.LastAccessTimeUtc = lastAccess;
document.LastWriteTimeUtc = lastWrite;
document.FileName = "Property Test.txt";
document.EncryptTo(inputStream, new MemoryStream(buffer), AxCryptOptions.EncryptWithCompression);
using (V2AxCryptDocument decryptedDocument = new V2AxCryptDocument())
{
Assert.That(decryptedDocument.Load(new Passphrase("properties"), new V2Aes256CryptoFactory().CryptoId, new MemoryStream(buffer)), Is.True);
Assert.That(decryptedDocument.CreationTimeUtc, Is.EqualTo(create));
Assert.That(decryptedDocument.LastAccessTimeUtc, Is.EqualTo(lastAccess));
Assert.That(decryptedDocument.LastWriteTimeUtc, Is.EqualTo(lastWrite));
Assert.That(decryptedDocument.FileName, Is.EqualTo("Property Test.txt"));
}
}
}
}
private static void TestEncryptWithHmacHelper(int length, AxCryptOptions options)
{
byte[] output;
byte[] hmacKey;
using (MemoryStream inputStream = new MemoryStream())
{
byte[] text = Resolve.RandomGenerator.Generate(length);
inputStream.Write(text, 0, text.Length);
inputStream.Position = 0;
using (MemoryStream outputStream = new MemoryStream())
{
using (V2AxCryptDocument document = new V2AxCryptDocument(new EncryptionParameters(new V2Aes256CryptoFactory().CryptoId, new Passphrase("Secret")), 100))
{
document.EncryptTo(inputStream, outputStream, options);
output = outputStream.ToArray();
hmacKey = document.DocumentHeaders.GetHmacKey();
}
}
}
byte[] hmacBytesFromHeaders = new byte[V2Hmac.RequiredLength];
Array.Copy(output, output.Length - V2Hmac.RequiredLength, hmacBytesFromHeaders, 0, V2Hmac.RequiredLength);
V2Hmac hmacFromHeaders = new V2Hmac(hmacBytesFromHeaders);
byte[] dataToHmac = new byte[output.Length - (V2Hmac.RequiredLength + 5)];
Array.Copy(output, 0, dataToHmac, 0, dataToHmac.Length);
HMACSHA512 hmac = new HMACSHA512(hmacKey);
hmac.TransformFinalBlock(dataToHmac, 0, dataToHmac.Length);
V2Hmac hmacFromCalculation = new V2Hmac(hmac.Hash);
Assert.That(hmacFromHeaders, Is.EqualTo(hmacFromCalculation));
}
public void TestDecryptToWithInvalidArgument()
{
Stream nullStream = null;
using (IAxCryptDocument document = new V2AxCryptDocument())
{
Assert.Throws <ArgumentNullException>(() => document.DecryptTo(nullStream));
}
using (MemoryStream inputStream = new MemoryStream())
{
byte[] text = Resolve.RandomGenerator.Generate(1000);
inputStream.Write(text, 0, text.Length);
inputStream.Position = 0;
byte[] buffer = new byte[2500];
using (IAxCryptDocument document = new V2AxCryptDocument(new EncryptionParameters(new V2Aes256CryptoFactory().CryptoId, new Passphrase("passphrase")), 113))
{
document.EncryptTo(inputStream, new MemoryStream(buffer), AxCryptOptions.EncryptWithCompression);
using (V2AxCryptDocument decryptedDocument = new V2AxCryptDocument())
{
Assert.That(decryptedDocument.Load(new Passphrase("incorrect"), new V2Aes256CryptoFactory().CryptoId, new MemoryStream(buffer)), Is.False);
Assert.Throws <InternalErrorException>(() => decryptedDocument.DecryptTo(Stream.Null));
}
}
}
}
private static void TestEncryptDecryptHelper(int length, AxCryptOptions options)
{
using (MemoryStream inputStream = new MemoryStream())
{
byte[] text = Resolve.RandomGenerator.Generate(length);
inputStream.Write(text, 0, text.Length);
inputStream.Position = 0;
byte[] buffer = new byte[5500 + length];
using (IAxCryptDocument document = new V2AxCryptDocument(new EncryptionParameters(new V2Aes256CryptoFactory().CryptoId, new Passphrase("passphrase")), 113))
{
document.EncryptTo(inputStream, new MemoryStream(buffer), options);
}
using (V2AxCryptDocument decryptedDocument = new V2AxCryptDocument())
{
Assert.That(decryptedDocument.Load(new Passphrase("passphrase"), new V2Aes256CryptoFactory().CryptoId, new MemoryStream(buffer)), Is.True);
byte[] plain;
using (MemoryStream decryptedStream = new MemoryStream())
{
decryptedDocument.DecryptTo(decryptedStream);
plain = decryptedStream.ToArray();
}
Assert.That(plain.IsEquivalentTo(text));
}
}
}
public override IAxCryptDocument Document(Passphrase passphrase, Guid cryptoId, Headers headers)
{
V2AxCryptDocument v2Document = new V2AxCryptDocument(this);
v2Document.Load(passphrase, cryptoId, headers);
return(v2Document);
}
public async Task TestSimpleEncryptFile()
{
FileOperationsController controller = new FileOperationsController();
string destinationPath = String.Empty;
controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
e.LogOnIdentity = new LogOnIdentity("allan");
};
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
};
FileOperationContext status = await controller.EncryptFileAsync(New <IDataStore>(_davidCopperfieldTxtPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The status should indicate success.");
IDataStore destinationInfo = New <IDataStore>(destinationPath);
Assert.That(destinationInfo.IsAvailable, "After encryption the destination file should be created.");
using (V2AxCryptDocument document = new V2AxCryptDocument())
{
using (Stream stream = destinationInfo.OpenRead())
{
document.Load(new Passphrase("allan"), new V2Aes256CryptoFactory().CryptoId, stream);
Assert.That(document.PassphraseIsValid, "The encrypted document should be valid and encrypted with the passphrase given.");
}
}
}
public void TestEncryptToInvalidArguments()
{
Stream nullStream = null;
using (IAxCryptDocument document = new V2AxCryptDocument())
{
Assert.Throws <ArgumentNullException>(() => document.EncryptTo(nullStream, Stream.Null, AxCryptOptions.EncryptWithCompression));
Assert.Throws <ArgumentNullException>(() => document.EncryptTo(Stream.Null, nullStream, AxCryptOptions.EncryptWithCompression));
Assert.Throws <ArgumentException>(() => document.EncryptTo(Stream.Null, Stream.Null, AxCryptOptions.None));
Assert.Throws <ArgumentException>(() => document.EncryptTo(Stream.Null, Stream.Null, AxCryptOptions.EncryptWithCompression | AxCryptOptions.EncryptWithoutCompression));
}
}
public override IAxCryptDocument Document(IAsymmetricPrivateKey privateKey, Guid cryptoId, Headers headers)
{
V2AxCryptDocument v2Document = new V2AxCryptDocument();
if (cryptoId == new V1Aes128CryptoFactory().CryptoId)
{
return(v2Document);
}
v2Document.Load(privateKey, cryptoId, headers);
return(v2Document);
}
public void TestV2Document()
{
using (MemoryStream inputStream = new MemoryStream())
{
byte[] text = Resolve.RandomGenerator.Generate(500);
inputStream.Write(text, 0, text.Length);
inputStream.Position = 0;
byte[] buffer = new byte[2500];
using (V2AxCryptDocument document = new V2AxCryptDocument(new EncryptionParameters(new V2Aes256CryptoFactory().CryptoId, new Passphrase("properties")), 15))
{
document.EncryptTo(inputStream, new MemoryStream(buffer), AxCryptOptions.EncryptWithCompression);
}
AxCryptFactory axFactory = new AxCryptFactory();
IEnumerable <DecryptionParameter> decryptionParameters = DecryptionParameter.CreateAll(new Passphrase[] { new Passphrase("properties") }, null, new Guid[] { new V2Aes256CryptoFactory().CryptoId });
using (IAxCryptDocument decryptedDocument = axFactory.CreateDocument(decryptionParameters, new MemoryStream(buffer)))
{
Assert.That(decryptedDocument.PassphraseIsValid);
}
}
}
private static byte[] EncrytionHelper(EncryptionParameters encryptionParameters, string fileName, AxCryptOptions options, byte[] plainText)
{
byte[] output;
using (MemoryStream inputStream = new MemoryStream(plainText))
{
using (MemoryStream outputStream = new MemoryStream())
{
using (V2AxCryptDocument document = new V2AxCryptDocument(encryptionParameters, 1000))
{
document.FileName = fileName;
document.CreationTimeUtc = New <INow>().Utc;
document.LastAccessTimeUtc = document.CreationTimeUtc;
document.LastWriteTimeUtc = document.CreationTimeUtc;
document.EncryptTo(inputStream, outputStream, options);
output = outputStream.ToArray();
}
}
}
return(output);
}
public void TestDecryptWithInvalidHmac()
{
using (MemoryStream inputStream = new MemoryStream())
{
byte[] text = Resolve.RandomGenerator.Generate(1000);
inputStream.Write(text, 0, text.Length);
inputStream.Position = 0;
byte[] buffer = new byte[3000];
using (IAxCryptDocument document = new V2AxCryptDocument(new EncryptionParameters(new V2Aes256CryptoFactory().CryptoId, new Passphrase("passphrase")), 113))
{
document.EncryptTo(inputStream, new MemoryStream(buffer), AxCryptOptions.EncryptWithoutCompression);
buffer[1000] = (byte)(buffer[1000] + 1);
using (V2AxCryptDocument decryptedDocument = new V2AxCryptDocument())
{
Assert.That(decryptedDocument.Load(new Passphrase("passphrase"), new V2Aes256CryptoFactory().CryptoId, new MemoryStream(buffer)), Is.True);
Assert.Throws <Axantum.AxCrypt.Core.Runtime.IncorrectDataException>(() => decryptedDocument.DecryptTo(Stream.Null));
}
}
}
}
public void TestDecryptToWithReaderWronglyPositioned()
{
using (MemoryStream inputStream = new MemoryStream())
{
byte[] text = Resolve.RandomGenerator.Generate(1000);
inputStream.Write(text, 0, text.Length);
inputStream.Position = 0;
byte[] buffer = new byte[2500];
using (IAxCryptDocument document = new V2AxCryptDocument(new EncryptionParameters(new V2Aes256CryptoFactory().CryptoId, new Passphrase("passphrase")), 113))
{
document.EncryptTo(inputStream, new MemoryStream(buffer), AxCryptOptions.EncryptWithCompression);
Headers headers = new Headers();
AxCryptReader reader = headers.CreateReader(new LookAheadStream(new MemoryStream(buffer)));
using (V2AxCryptDocument decryptedDocument = new V2AxCryptDocument(reader))
{
Assert.That(decryptedDocument.Load(new Passphrase("passphrase"), new V2Aes256CryptoFactory().CryptoId, headers), Is.True);
reader.SetStartOfData();
Assert.Throws <InvalidOperationException>(() => decryptedDocument.DecryptTo(Stream.Null));
}
}
}
}
