public static void DecryptAndOpenFile(IRuntimeFileInfo encryptedDocument, Passphrase passphrase, ProgressContext progress, Action<string, ProgressContext> failure = null)
{
string tempPath = Path.GetTempPath();
string decryptedFileName;
lastUsedKey = passphrase.DerivedPassphrase;
if (!TryDecrypt(encryptedDocument, tempPath, lastUsedKey, progress, out decryptedFileName)) {
failure("Could not open file", progress);
return;
}
string fullPathToDecryptedFile = Path.Combine(tempPath, decryptedFileName);
IRuntimeFileInfo decryptedFile = OS.Current.FileInfo(fullPathToDecryptedFile);
NSDictionary userInfo = new NSDictionary(Launcher.TargetFileUserInfoKey, decryptedFile.FullName);
NSNotification notification = NSNotification.FromName(Launcher.FileDecryptedNotification, new NSObject(), userInfo);
NSNotificationCenter.DefaultCenter.PostNotification(notification);
ILauncher launcher = OS.Current.Launch (fullPathToDecryptedFile);
launcher.Exited += (sender, e) => {
fileSystemState.CheckActiveFiles(ChangedEventMode.RaiseOnlyOnModified, new ProgressContext());
};
fileSystemState.Add (new ActiveFile(encryptedDocument, decryptedFile, lastUsedKey, ActiveFileStatus.AssumedOpenAndDecrypted, launcher));
//fileSystemState.Save ();
}
public static void TestChangePassphraseForSimpleFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct and should work!");
Passphrase newPassphrase = new Passphrase("b");
using (Stream changedStream = new MemoryStream())
{
DocumentHeaders outputDocumentHeaders = new DocumentHeaders(document.DocumentHeaders);
outputDocumentHeaders.SetCurrentVersion();
outputDocumentHeaders.RewrapMasterKey(newPassphrase.DerivedPassphrase);
document.CopyEncryptedTo(outputDocumentHeaders, changedStream, new ProgressContext());
changedStream.Position = 0;
using (AxCryptDocument changedDocument = new AxCryptDocument())
{
bool changedKeyIsOk = changedDocument.Load(changedStream, newPassphrase.DerivedPassphrase);
Assert.That(changedKeyIsOk, Is.True, "The changed passphrase provided is correct and should work!");
using (MemoryStream plaintextStream = new MemoryStream())
{
changedDocument.DecryptTo(plaintextStream, new ProgressContext());
Assert.That(Encoding.ASCII.GetString(plaintextStream.GetBuffer(), 0, (int)plaintextStream.Length), Is.EqualTo("HelloWorld"), "Unexpected result of decryption.");
Assert.That(changedDocument.DocumentHeaders.PlaintextLength, Is.EqualTo(10), "'HelloWorld' should be 10 bytes uncompressed plaintext.");
}
}
}
}
}
public static void TestPassphraseConstructor()
{
Passphrase passphrase = new Passphrase("A Passphrase");
AesKey derivedKey = passphrase.DerivedPassphrase;
Assert.That(derivedKey.Length, Is.EqualTo(16), "The default derived key is 128 bits.");
Assert.Throws<ArgumentNullException>(() =>
{
passphrase = new Passphrase(null);
});
}
public static void TestAnsiFileNameFromSimpleFile()
{
using (Stream testStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt))
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(testStream, passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
string fileName = document.DocumentHeaders.FileName;
Assert.That(fileName, Is.EqualTo("HelloWorld-Key-a.txt"), "Wrong file name");
}
}
}
public static void TestBadKey()
{
using (Stream testStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt))
{
using (AxCryptReader reader = AxCryptReader.Create(testStream))
{
Passphrase passphrase = new Passphrase("b");
DocumentHeaders documentHeaders = new DocumentHeaders(passphrase.DerivedPassphrase);
bool isPassphraseValid = documentHeaders.Load(reader);
Assert.That(isPassphraseValid, Is.False, "The passphrase is intentionally wrong for this test case.");
Assert.That(documentHeaders.HmacSubkey, Is.Null, "Since the passphrase is wrong, HmacSubkey should return null.");
Assert.That(documentHeaders.DataSubkey, Is.Null, "Since the passphrase is wrong, DataSubkey should return null.");
Assert.That(documentHeaders.HeadersSubkey, Is.Null, "Since the passphrase is wrong, HeadersSubkey should return null.");
}
}
}
/// <summary>
/// Instantiate a thumb print
/// </summary>
/// <param name="passphrase">The passphrase to thumbprint.</param>
/// <param name="salt">The salt to use.</param>
public SymmetricKeyThumbprint(Passphrase passphrase, Salt salt, long keyWrapIterations)
{
if (passphrase == null)
{
throw new ArgumentNullException("passphrase");
}
if (salt == null)
{
throw new ArgumentNullException("salt");
}
ICryptoFactory factory = Resolve.CryptoFactory.Minimum;
ICrypto crypto = factory.CreateCrypto(factory.RestoreDerivedKey(passphrase, salt, CryptoFactory.DerivationIterations).DerivedKey, null, 0);
KeyWrap keyWrap = new KeyWrap(salt, keyWrapIterations, KeyWrapMode.Specification);
byte[] wrap = keyWrap.Wrap(crypto, crypto.Key);
_bytes = wrap.Reduce(6);
}
/// <summary>
/// Initializes a new instance of the <see cref="V1DerivedKey"/> class.
/// </summary>
/// <param name="passphrase">The passphrase.</param>
public V1DerivedKey(Passphrase passphrase)
{
if (passphrase == null)
{
throw new ArgumentNullException("passphrase");
}
HashAlgorithm hashAlgorithm = New <Sha1>();
byte[] ansiBytes = Encoding.GetEncoding("Windows-1252").GetBytes(passphrase.Text);
byte[] ansiBytesExtra = ansiBytes.Append(passphrase.Extra());
byte[] hash = hashAlgorithm.ComputeHash(ansiBytesExtra);
byte[] derivedKey = new byte[16];
Array.Copy(hash, derivedKey, derivedKey.Length);
DerivationSalt = Salt.Zero;
DerivationIterations = 0;
DerivedKey = new SymmetricKey(derivedKey);
}
/// <summary>
/// Creates an enumeration of all relevant DecryptionParameters from the provided arguments.
/// </summary>
/// <param name="passphrases">The passphrases or null.</param>
/// <param name="privateKeys">The private keys or null.</param>
/// <param name="cryptoIds">The crypto ids.</param>
/// <returns></returns>
public static IEnumerable <DecryptionParameter> CreateAll(IEnumerable <Passphrase> passphrases, IEnumerable <IAsymmetricPrivateKey> privateKeys, IEnumerable <Guid> cryptoIds)
{
if (cryptoIds == null)
{
throw new ArgumentNullException("cryptoIds");
}
List <DecryptionParameter> all = new List <DecryptionParameter>();
foreach (Passphrase passphrase in passphrases ?? new Passphrase[0])
{
foreach (Guid cryptoId in cryptoIds)
{
all.Add(new DecryptionParameter(passphrase, cryptoId));
if (cryptoId != new V1Aes128CryptoFactory().CryptoId)
{
continue;
}
string filtered = FilterV1Disallowed(passphrase.Text);
if (string.CompareOrdinal(filtered, passphrase.Text) == 0)
{
continue;
}
all.Add(new DecryptionParameter(Passphrase.Create(filtered), cryptoId));
}
}
foreach (IAsymmetricPrivateKey privateKey in privateKeys ?? new IAsymmetricPrivateKey[0])
{
foreach (Guid cryptoId in cryptoIds)
{
if (cryptoId == new V1Aes128CryptoFactory().CryptoId)
{
continue;
}
all.Add(new DecryptionParameter(privateKey, cryptoId));
}
}
return(all);
}
private bool OpenAxCryptDocument(string fullName, FileOperationEventArgs e)
{
e.AxCryptDocument = null;
try
{
IRuntimeFileInfo source = OS.Current.FileInfo(fullName);
e.OpenFileFullName = source.FullName;
foreach (AesKey key in _fileSystemState.KnownKeys.Keys)
{
e.AxCryptDocument = AxCryptFile.Document(source, key, new ProgressContext());
if (e.AxCryptDocument.PassphraseIsValid)
{
break;
}
e.AxCryptDocument.Dispose();
e.AxCryptDocument = null;
}
Passphrase passphrase;
while (e.AxCryptDocument == null)
{
OnQueryDecryptionPassphrase(e);
if (e.Cancel)
{
e.Status = FileOperationStatus.Canceled;
return false;
}
passphrase = new Passphrase(e.Passphrase);
e.AxCryptDocument = AxCryptFile.Document(source, passphrase.DerivedPassphrase, new ProgressContext());
if (!e.AxCryptDocument.PassphraseIsValid)
{
e.AxCryptDocument.Dispose();
e.AxCryptDocument = null;
continue;
}
e.Key = passphrase.DerivedPassphrase;
OnKnownKeyAdded(e);
}
}
catch (IOException ioex)
{
if (e.AxCryptDocument != null)
{
e.AxCryptDocument.Dispose();
e.AxCryptDocument = null;
}
FileOperationStatus status = ioex is FileNotFoundException ? FileOperationStatus.FileDoesNotExist : FileOperationStatus.Exception;
e.Status = status;
return false;
}
return true;
}
public static void TestDecryptOfTooNewFileVersion()
{
DateTime creationTimeUtc = new DateTime(2012, 1, 1, 1, 2, 3, DateTimeKind.Utc);
DateTime lastAccessTimeUtc = creationTimeUtc + new TimeSpan(1, 0, 0);
DateTime lastWriteTimeUtc = creationTimeUtc + new TimeSpan(2, 0, 0); ;
using (Stream inputStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.UTF8.GetBytes("AxCrypt is Great!")))
{
using (Stream outputStream = new MemoryStream())
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
DocumentHeadersForTest headers = new DocumentHeadersForTest(passphrase.DerivedPassphrase);
headers.FileName = "MyFile.txt";
headers.CreationTimeUtc = creationTimeUtc;
headers.LastAccessTimeUtc = lastAccessTimeUtc;
headers.LastWriteTimeUtc = lastWriteTimeUtc;
headers.SetNextFileVersionMajor();
document.DocumentHeaders = headers;
document.EncryptTo(headers, inputStream, outputStream, AxCryptOptions.EncryptWithoutCompression, new ProgressContext());
}
outputStream.Position = 0;
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
Assert.Throws<FileFormatException>(() => { document.Load(outputStream, passphrase.DerivedPassphrase); });
}
}
}
}
public static void TestHmac()
{
using (Stream inputStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt))
{
using (AxCryptReader axCryptReader = new AxCryptStreamReader(inputStream))
{
Assert.Throws<InvalidOperationException>(() =>
{
if (axCryptReader.Hmac == null) { }
}, "The reader is not positioned properly to get the HMAC.");
Passphrase passphrase = new Passphrase("a");
DocumentHeaders documentHeaders = new DocumentHeaders(passphrase.DerivedPassphrase);
bool keyIsOk = documentHeaders.Load(axCryptReader);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (Stream encrypedDataStream = axCryptReader.CreateEncryptedDataStream(documentHeaders.HmacSubkey.Key, documentHeaders.CipherTextLength, new ProgressContext()))
{
Assert.Throws<InvalidOperationException>(() =>
{
if (axCryptReader.Hmac == null) { }
}, "We have not read the encrypted data yet.");
Assert.That(axCryptReader.Read(), Is.False, "The reader should be at end of stream now, and Read() should return false.");
encrypedDataStream.CopyTo(Stream.Null, 4096);
Assert.That(documentHeaders.Hmac, Is.EqualTo(axCryptReader.Hmac), "The HMAC should be correct.");
axCryptReader.Dispose();
Assert.Throws<ObjectDisposedException>(() =>
{
DataHmac disposedHmac = axCryptReader.Hmac;
Object.Equals(disposedHmac, null);
}, "The reader is disposed.");
}
}
}
}
public LogOnIdentity(EmailAddress userEmail, Passphrase passphrase)
: this(passphrase)
{
UserEmail = userEmail;
}
public static void TestDecryptCompressedFromLargerFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("Å ä Ö");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
document.DecryptTo(plaintextStream, new ProgressContext());
string text = Encoding.UTF8.GetString(plaintextStream.GetBuffer(), 0, (int)plaintextStream.Length);
Assert.That(text, Is.StringStarting("The Project Gutenberg EBook of David Copperfield, by Charles Dickens"), "Unexpected start of David Copperfield.");
Assert.That(text, Is.StringEnding("subscribe to our email newsletter to hear about new eBooks." + (Char)13 + (Char)10), "Unexpected end of David Copperfield.");
Assert.That(text.Length, Is.EqualTo(1992490), "Wrong length of full text of David Copperfield.");
Assert.That(document.DocumentHeaders.PlaintextLength, Is.EqualTo(795855), "Wrong expected length of compressed text of David Copperfield.");
}
}
}
private void enterPassphraseToolStripMenuItem_Click(object sender, EventArgs e)
{
string passphraseText = AskForDecryptPassphrase();
if (passphraseText == null)
{
return;
}
Passphrase passphrase = new Passphrase(passphraseText);
persistentState.Current.KnownKeys.Add(passphrase.DerivedPassphrase);
}
public static void TestInvalidHmacInCopyEncryptedTo()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct and should work!");
Passphrase newPassphrase = new Passphrase("b");
using (Stream changedStream = new MemoryStream())
{
DocumentHeaders outputDocumentHeaders = new DocumentHeaders(document.DocumentHeaders);
outputDocumentHeaders.SetCurrentVersion();
outputDocumentHeaders.RewrapMasterKey(newPassphrase.DerivedPassphrase);
byte[] modifiedHmacBytes = document.DocumentHeaders.Hmac.GetBytes();
modifiedHmacBytes[0] += 1;
document.DocumentHeaders.Hmac = new DataHmac(modifiedHmacBytes);
Assert.Throws<Axantum.AxCrypt.Core.Runtime.InvalidDataException>(() =>
{
document.CopyEncryptedTo(outputDocumentHeaders, changedStream, new ProgressContext());
});
}
}
}
public static void TestInvalidArguments()
{
using (Stream inputStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.UTF8.GetBytes("AxCrypt is Great!")))
{
using (Stream outputStream = new MemoryStream())
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
DocumentHeaders headers = new DocumentHeaders(passphrase.DerivedPassphrase);
Assert.Throws<ArgumentNullException>(() => { document.EncryptTo(null, inputStream, outputStream, AxCryptOptions.EncryptWithCompression, new ProgressContext()); });
Assert.Throws<ArgumentNullException>(() => { document.EncryptTo(headers, null, outputStream, AxCryptOptions.EncryptWithCompression, new ProgressContext()); });
Assert.Throws<ArgumentNullException>(() => { document.EncryptTo(headers, inputStream, null, AxCryptOptions.EncryptWithCompression, new ProgressContext()); });
Assert.Throws<ArgumentNullException>(() => { document.EncryptTo(headers, inputStream, outputStream, AxCryptOptions.EncryptWithCompression, null); });
Assert.Throws<ArgumentException>(() => { document.EncryptTo(headers, inputStream, new NonSeekableStream(), AxCryptOptions.EncryptWithCompression, new ProgressContext()); });
Assert.Throws<ArgumentException>(() => { document.EncryptTo(headers, inputStream, outputStream, AxCryptOptions.EncryptWithCompression | AxCryptOptions.EncryptWithoutCompression, new ProgressContext()); });
Assert.Throws<ArgumentException>(() => { document.EncryptTo(headers, inputStream, outputStream, AxCryptOptions.None, new ProgressContext()); });
Assert.Throws<ArgumentNullException>(() => { document.CopyEncryptedTo(null, outputStream, new ProgressContext()); });
Assert.Throws<ArgumentNullException>(() => { document.CopyEncryptedTo(headers, null, new ProgressContext()); });
Assert.Throws<ArgumentException>(() => { document.CopyEncryptedTo(headers, new NonSeekableStream(), new ProgressContext()); });
Assert.Throws<InternalErrorException>(() => { document.CopyEncryptedTo(headers, outputStream, new ProgressContext()); });
}
}
}
}
public static void TestHmacFromSimpleFile()
{
DataHmac expectedHmac = new DataHmac(new byte[] { 0xF9, 0xAF, 0x2E, 0x67, 0x7D, 0xCF, 0xC9, 0xFE, 0x06, 0x4B, 0x39, 0x08, 0xE7, 0x5A, 0x87, 0x81 });
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
DataHmac hmac = document.DocumentHeaders.Hmac;
Assert.That(hmac.GetBytes(), Is.EqualTo(expectedHmac.GetBytes()), "Wrong HMAC");
}
}
public static void TestHmacCalculationFromSimpleFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
document.DecryptTo(Stream.Null, new ProgressContext());
}
}
public static void TestFileTimesFromSimpleFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
string creationTime = document.DocumentHeaders.CreationTimeUtc.ToString(CultureInfo.InvariantCulture);
Assert.That(creationTime, Is.EqualTo("01/13/2012 17:17:18"), "Checking creation time.");
string lastAccessTime = document.DocumentHeaders.LastAccessTimeUtc.ToString(CultureInfo.InvariantCulture);
Assert.That(lastAccessTime, Is.EqualTo("01/13/2012 17:17:18"), "Checking last access time.");
string lastWriteTime = document.DocumentHeaders.LastWriteTimeUtc.ToString(CultureInfo.InvariantCulture);
Assert.That(lastWriteTime, Is.EqualTo("01/13/2012 17:17:45"), "Checking last modify time.");
}
}
public static void TestFailedHmacCalculationFromSimpleFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
document.DocumentHeaders.Hmac = new DataHmac(new byte[document.DocumentHeaders.Hmac.Length]);
Assert.Throws<Axantum.AxCrypt.Core.Runtime.InvalidDataException>(() =>
{
document.DecryptTo(Stream.Null, new ProgressContext());
});
}
}
public static void TestDecryptUncompressedWithPaddingError()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
using (MemoryStream encryptedFile = FakeRuntimeFileInfo.ExpandableMemoryStream((byte[])Resources.helloworld_key_a_txt.Clone()))
{
encryptedFile.Seek(-1, SeekOrigin.End);
byte lastByte = (byte)encryptedFile.ReadByte();
++lastByte;
encryptedFile.Seek(-1, SeekOrigin.End);
encryptedFile.WriteByte(lastByte);
encryptedFile.Position = 0;
bool keyIsOk = document.Load(encryptedFile, passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
Assert.Throws<CryptographicException>(() => { document.DecryptTo(plaintextStream, new ProgressContext()); });
}
}
}
}
public IDerivedKey RestoreDerivedKey(Passphrase passphrase, Salt salt, int derivationIterations)
{
return(new V2DerivedKey(passphrase, salt, derivationIterations, 128));
}
public static void TestDecryptUncompressedWithCancel()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
ProgressContext progress = new ProgressContext(TimeSpan.Zero);
progress.Progressing += (object sender, ProgressEventArgs e) =>
{
throw new OperationCanceledException();
};
Assert.Throws<OperationCanceledException>(() => { document.DecryptTo(plaintextStream, progress); });
}
}
}
public static void TestInvalidPassphraseWithSimpleFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("b");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.False, "The passphrase provided is wrong!");
}
}
public static void TestDecryptCompressedFromLegacy0B6()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("åäö");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.tst_0_0b6_key__aaaeoe__medium_html), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "A correct passphrase was provided, but it was not accepted.");
Assert.That(document.DocumentHeaders.IsCompressed, Is.True, "The file is compressed.");
Assert.That(document.DocumentHeaders.FileName, Is.EqualTo("readme.html"), "The file name should be 'readme.html'.");
using (MemoryStream plaintextStream = new MemoryStream())
{
document.DecryptTo(plaintextStream, new ProgressContext());
Assert.That(document.DocumentHeaders.PlaintextLength, Is.EqualTo(3736), "The compressed content should be recorded as 3736 bytes in the headers.");
Assert.That(plaintextStream.Length, Is.EqualTo(9528), "The file should be 9528 bytes uncompressed plaintext in actual fact.");
}
}
}
public static void TestIsCompressedFromLargerFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("Å ä Ö");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
bool isCompressed = document.DocumentHeaders.IsCompressed;
Assert.That(isCompressed, Is.True, "This file should be compressed.");
}
}
public override int GetHashCode()
{
return(Passphrase.GetHashCode() ^ _keyPairs.GetHashCode());
}
public static void TestIsCompressedFromSimpleFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
bool isCompressed = document.DocumentHeaders.IsCompressed;
Assert.That(isCompressed, Is.False, "This file should not be compressed.");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LogOnIdentity"/> class.
/// </summary>
/// <param name="passphrase">The passphrase.</param>
public LogOnIdentity(Passphrase passphrase)
: this(new UserKeyPair[0], passphrase)
{
}
public static void TestNoMagicGuidFound()
{
byte[] dummy = Encoding.ASCII.GetBytes("This is a string that generates some bytes, none of which will match the magic GUID");
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
Assert.Throws<FileFormatException>(() => { document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(dummy), passphrase.DerivedPassphrase); }, "Calling with dummy data that does not contain a GUID.");
}
}
public static void TestDecryptAfterFailedLoad()
{
using (Stream testStream = new MemoryStream())
{
AxCrypt1Guid.Write(testStream);
testStream.Position = 0;
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("Å ä Ö");
Assert.Throws<FileFormatException>(() => { document.Load(testStream, passphrase.DerivedPassphrase); });
using (MemoryStream plaintextStream = new MemoryStream())
{
Assert.Throws<InternalErrorException>(() => { document.DecryptTo(plaintextStream, new ProgressContext()); });
}
}
}
}
public static void TestSimpleEncryptToWithoutCompression()
{
DateTime creationTimeUtc = new DateTime(2012, 1, 1, 1, 2, 3, DateTimeKind.Utc);
DateTime lastAccessTimeUtc = creationTimeUtc + new TimeSpan(1, 0, 0);
DateTime lastWriteTimeUtc = creationTimeUtc + new TimeSpan(2, 0, 0); ;
using (Stream inputStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.UTF8.GetBytes("AxCrypt is Great!")))
{
using (Stream outputStream = new MemoryStream())
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
DocumentHeaders headers = new DocumentHeaders(passphrase.DerivedPassphrase);
headers.FileName = "MyFile.txt";
headers.CreationTimeUtc = creationTimeUtc;
headers.LastAccessTimeUtc = lastAccessTimeUtc;
headers.LastWriteTimeUtc = lastWriteTimeUtc;
document.DocumentHeaders = headers;
document.EncryptTo(headers, inputStream, outputStream, AxCryptOptions.EncryptWithoutCompression, new ProgressContext());
}
outputStream.Position = 0;
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(outputStream, passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
Assert.That(document.DocumentHeaders.FileName, Is.EqualTo("MyFile.txt"));
Assert.That(document.DocumentHeaders.CreationTimeUtc, Is.EqualTo(creationTimeUtc));
Assert.That(document.DocumentHeaders.LastAccessTimeUtc, Is.EqualTo(lastAccessTimeUtc));
Assert.That(document.DocumentHeaders.LastWriteTimeUtc, Is.EqualTo(lastWriteTimeUtc));
using (MemoryStream plaintextStream = new MemoryStream())
{
document.DecryptTo(plaintextStream, new ProgressContext());
Assert.That(document.DocumentHeaders.UncompressedLength, Is.EqualTo(-1), "'AxCrypt is Great!' should not return a value at all for uncompressed, since it was not compressed.");
Assert.That(document.DocumentHeaders.PlaintextLength, Is.EqualTo(17), "'AxCrypt is Great!' is 17 bytes plaintext length.");
Assert.That(Encoding.ASCII.GetString(plaintextStream.GetBuffer(), 0, (int)plaintextStream.Length), Is.EqualTo("AxCrypt is Great!"), "Unexpected result of decryption.");
}
}
}
}
}
private bool EncryptFilePreparation(string fullName)
{
if (String.Compare(Path.GetExtension(fullName), OS.Current.AxCryptExtension, StringComparison.OrdinalIgnoreCase) == 0)
{
_eventArgs.Status = FileOperationStatus.FileAlreadyEncrypted;
return false;
}
IRuntimeFileInfo sourceFileInfo = OS.Current.FileInfo(fullName);
IRuntimeFileInfo destinationFileInfo = OS.Current.FileInfo(AxCryptFile.MakeAxCryptFileName(sourceFileInfo));
_eventArgs.SaveFileFullName = destinationFileInfo.FullName;
_eventArgs.OpenFileFullName = fullName;
if (destinationFileInfo.Exists)
{
OnQuerySaveFileAs(_eventArgs);
if (_eventArgs.Cancel)
{
_eventArgs.Status = FileOperationStatus.Canceled;
return false;
}
}
if (_fileSystemState.KnownKeys.DefaultEncryptionKey == null)
{
OnQueryEncryptionPassphrase(_eventArgs);
if (_eventArgs.Cancel)
{
_eventArgs.Status = FileOperationStatus.Canceled;
return false;
}
Passphrase passphrase = new Passphrase(_eventArgs.Passphrase);
_eventArgs.Key = passphrase.DerivedPassphrase;
}
else
{
_eventArgs.Key = _fileSystemState.KnownKeys.DefaultEncryptionKey;
}
return true;
}
public static void TestDecryptCompressedWithTruncatedFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("Å ä Ö");
using (MemoryStream encryptedFile = FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt))
{
encryptedFile.SetLength(encryptedFile.Length / 2);
encryptedFile.Position = 0;
bool keyIsOk = document.Load(encryptedFile, passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
Assert.Throws<CryptographicException>(() => { document.DecryptTo(plaintextStream, new ProgressContext()); });
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EncryptionParameters"/> class.
/// </summary>
/// <param name="passphrase">The passphrase.</param>
public EncryptionParameters(Guid cryptoId, Passphrase passphrase)
: this(cryptoId)
{
_identity = new LogOnIdentity(passphrase);
}
private void EncryptFile(string file, IThreadWorker worker, ProgressContext progress)
{
FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);
operationsController.QuerySaveFileAs += (object sender, FileOperationEventArgs e) =>
{
using (SaveFileDialog sfd = new SaveFileDialog())
{
sfd.Title = Resources.EncryptFileSaveAsDialogTitle;
sfd.AddExtension = true;
sfd.ValidateNames = true;
sfd.CheckPathExists = true;
sfd.DefaultExt = OS.Current.AxCryptExtension;
sfd.FileName = e.SaveFileFullName;
sfd.Filter = Resources.EncryptedFileDialogFilterPattern.InvariantFormat(OS.Current.AxCryptExtension);
sfd.InitialDirectory = Path.GetDirectoryName(e.SaveFileFullName);
sfd.ValidateNames = true;
DialogResult saveAsResult = sfd.ShowDialog();
if (saveAsResult != DialogResult.OK)
{
e.Cancel = true;
return;
}
e.SaveFileFullName = sfd.FileName;
}
};
operationsController.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
string passphrase = AskForEncryptionPassphrase();
if (String.IsNullOrEmpty(passphrase))
{
e.Cancel = true;
return;
}
e.Passphrase = passphrase;
AesKey defaultEncryptionKey = new Passphrase(e.Passphrase).DerivedPassphrase;
persistentState.Current.KnownKeys.DefaultEncryptionKey = defaultEncryptionKey;
};
operationsController.Completed += (object sender, FileOperationEventArgs e) =>
{
if (e.Status == FileOperationStatus.FileAlreadyEncrypted)
{
e.Status = FileOperationStatus.Success;
return;
}
if (CheckStatusAndShowMessage(e.Status, e.OpenFileFullName))
{
IRuntimeFileInfo encryptedInfo = OS.Current.FileInfo(e.SaveFileFullName);
IRuntimeFileInfo decryptedInfo = OS.Current.FileInfo(FileOperation.GetTemporaryDestinationName(e.OpenFileFullName));
ActiveFile activeFile = new ActiveFile(encryptedInfo, decryptedInfo, e.Key, ActiveFileStatus.NotDecrypted, null);
persistentState.Current.Add(activeFile);
persistentState.Current.Save();
}
};
operationsController.EncryptFile(file, worker);
}
public V2DerivedKey(Passphrase passphrase, int keySize)
: this(passphrase, new Salt(256), CryptoFactory.DerivationIterations, keySize)
{
}
private void encryptionKeyToolStripButton_Click(object sender, EventArgs e)
{
if (persistentState.Current.KnownKeys.DefaultEncryptionKey == null)
{
string passphrase = AskForEncryptionPassphrase();
if (String.IsNullOrEmpty(passphrase))
{
return;
}
AesKey defaultEncryptionKey = new Passphrase(passphrase).DerivedPassphrase;
persistentState.Current.KnownKeys.DefaultEncryptionKey = defaultEncryptionKey;
}
else
{
persistentState.Current.KnownKeys.DefaultEncryptionKey = null;
}
SetToolButtonsState();
}
public IDerivedKey CreateDerivedKey(Passphrase passphrase)
{
return(new V2DerivedKey(passphrase, 128));
}
public static void TestDecryptUncompressedFromSimpleFile()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
document.DecryptTo(plaintextStream, new ProgressContext());
Assert.That(Encoding.ASCII.GetString(plaintextStream.GetBuffer(), 0, (int)plaintextStream.Length), Is.EqualTo("HelloWorld"), "Unexpected result of decryption.");
Assert.That(document.DocumentHeaders.PlaintextLength, Is.EqualTo(10), "'HelloWorld' should be 10 bytes uncompressed plaintext.");
}
}
}
