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 TestEncryptFileWithDefaultEncryptionKey() { _fileSystemState.KnownKeys.DefaultEncryptionKey = new Passphrase("default").DerivedPassphrase; FileOperationsController controller = new FileOperationsController(_fileSystemState); bool queryEncryptionPassphraseWasCalled = false; controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) => { queryEncryptionPassphraseWasCalled = true; }; string destinationPath = String.Empty; controller.Completed += (object sender, FileOperationEventArgs e) => { destinationPath = e.SaveFileFullName; }; FileOperationStatus status = controller.EncryptFile(_davidCopperfieldTxtPath); Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success."); Assert.That(!queryEncryptionPassphraseWasCalled, "No query of encryption passphrase should be needed since there is a default set."); IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath); Assert.That(destinationInfo.Exists, "After encryption the destination file should be created."); using (AxCryptDocument document = new AxCryptDocument()) { using (Stream stream = destinationInfo.OpenRead()) { document.Load(stream, new Passphrase("default").DerivedPassphrase); Assert.That(document.PassphraseIsValid, "The encrypted document should be valid and encrypted with the default passphrase given."); } } }
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 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 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 TestSmallEncryptDecrypt() { IRuntimeFileInfo sourceFileInfo = OS.Current.FileInfo(_testTextPath); IRuntimeFileInfo destinationFileInfo = sourceFileInfo.CreateEncryptedName(); Assert.That(destinationFileInfo.Name, Is.EqualTo("test-txt.axx"), "Wrong encrypted file name based on the plain text file name."); AxCryptFile.Encrypt(sourceFileInfo, destinationFileInfo, new Passphrase("axcrypt"), AxCryptOptions.EncryptWithCompression, new ProgressContext()); using (AxCryptDocument document = AxCryptFile.Document(destinationFileInfo, new Passphrase("axcrypt").DerivedPassphrase, new ProgressContext())) { Assert.That(document.PassphraseIsValid, Is.True, "The passphrase should be ok."); Assert.That(document.DocumentHeaders.FileName, Is.EqualTo("test.txt"), "Unexpected file name in headers."); Assert.That(document.DocumentHeaders.CreationTimeUtc, Is.EqualTo(FakeRuntimeFileInfo.TestDate1Utc)); Assert.That(document.DocumentHeaders.LastAccessTimeUtc, Is.EqualTo(FakeRuntimeFileInfo.TestDate2Utc)); Assert.That(document.DocumentHeaders.LastWriteTimeUtc, Is.EqualTo(FakeRuntimeFileInfo.TestDate3Utc)); IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(Path.Combine(_rootPath, "decrypted test.txt")); AxCryptFile.Decrypt(document, decryptedFileInfo, AxCryptOptions.SetFileTimes, new ProgressContext()); using (Stream decryptedStream = decryptedFileInfo.OpenRead()) { string decrypted = new StreamReader(decryptedStream, Encoding.UTF8).ReadToEnd(); Assert.That(decrypted, Is.EqualTo("This is a short file")); } Assert.That(decryptedFileInfo.CreationTimeUtc, Is.EqualTo(document.DocumentHeaders.CreationTimeUtc), "We're expecting file times to be set as the original from the headers."); Assert.That(decryptedFileInfo.LastAccessTimeUtc, Is.EqualTo(document.DocumentHeaders.LastAccessTimeUtc), "We're expecting file times to be set as the original from the headers."); Assert.That(decryptedFileInfo.LastWriteTimeUtc, Is.EqualTo(document.DocumentHeaders.LastWriteTimeUtc), "We're expecting file times to be set as the original from the headers."); } }
private static ActiveFile TryDecrypt(IRuntimeFileInfo sourceFileInfo, IRuntimeFileInfo destinationFolderInfo, IEnumerable <AesKey> keys, ProgressContext progress) { ActiveFile destinationActiveFile = null; foreach (AesKey key in keys) { if (OS.Log.IsInfoEnabled) { OS.Log.LogInfo("Decrypting '{0}'".InvariantFormat(sourceFileInfo.FullName)); } using (FileLock sourceLock = FileLock.Lock(sourceFileInfo)) { using (AxCryptDocument document = AxCryptFile.Document(sourceFileInfo, key, new ProgressContext())) { if (!document.PassphraseIsValid) { continue; } destinationActiveFile = DecryptActiveFileDocument(sourceFileInfo, destinationFolderInfo, document, progress); break; } } } return(destinationActiveFile); }
public static void TestOpenAndLaunchOfAxCryptDocumentWhenAlreadyDecrypted() { TestOpenAndLaunchOfAxCryptDocument(); FakeLauncher launcher = null; SetupAssembly.FakeRuntimeEnvironment.Launcher = ((string path) => { launcher = new FakeLauncher(path); return(launcher); }); FileOperationStatus status; using (AxCryptDocument document = new AxCryptDocument()) { using (Stream stream = OS.Current.FileInfo(_helloWorldAxxPath).OpenRead()) { document.Load(stream, new Passphrase("a").DerivedPassphrase); status = _fileSystemState.OpenAndLaunchApplication(_helloWorldAxxPath, document, new ProgressContext()); } } Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The launch should succeed."); Assert.That(launcher, Is.Not.Null, "There should be a call to launch."); Assert.That(Path.GetFileName(launcher.Path), Is.EqualTo("HelloWorld-Key-a.txt"), "The file should be decrypted and the name should be the original from the encrypted headers."); }
public static void TestDoubleDispose() { AxCryptDocument document = new AxCryptDocument(); document.Dispose(); document.Dispose(); }
public static void TestSimpleEncryptFile() { FileOperationsController controller = new FileOperationsController(_fileSystemState); string destinationPath = String.Empty; controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) => { e.Passphrase = "allan"; }; controller.Completed += (object sender, FileOperationEventArgs e) => { destinationPath = e.SaveFileFullName; }; FileOperationStatus status = controller.EncryptFile(_davidCopperfieldTxtPath); Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success."); IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath); Assert.That(destinationInfo.Exists, "After encryption the destination file should be created."); using (AxCryptDocument document = new AxCryptDocument()) { using (Stream stream = destinationInfo.OpenRead()) { document.Load(stream, new Passphrase("allan").DerivedPassphrase); Assert.That(document.PassphraseIsValid, "The encrypted document should be valid and encrypted with the passphrase given."); } } }
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 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 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 TestDecryptWithoutLoadFirstFromEmptyFile() { using (AxCryptDocument document = new AxCryptDocument()) { using (MemoryStream plaintextStream = new MemoryStream()) { Assert.Throws <InternalErrorException>(() => { document.DecryptTo(plaintextStream, new ProgressContext()); }); } } }
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 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."); } }
public static void TestOpenAndLaunchOfAxCryptDocumentArgumentNullException() { FileSystemState nullFileSystemState = null; string nullString = null; AxCryptDocument nullDocument = null; ProgressContext nullProgressContext = null; Assert.Throws <ArgumentNullException>(() => { nullFileSystemState.OpenAndLaunchApplication(_helloWorldAxxPath, new AxCryptDocument(), new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { _fileSystemState.OpenAndLaunchApplication(nullString, new AxCryptDocument(), new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { _fileSystemState.OpenAndLaunchApplication(_helloWorldAxxPath, nullDocument, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { _fileSystemState.OpenAndLaunchApplication(_helloWorldAxxPath, new AxCryptDocument(), nullProgressContext); }); }
public static void TestInvalidArguments() { IRuntimeFileInfo sourceFileInfo = OS.Current.FileInfo(_testTextPath); IRuntimeFileInfo destinationFileInfo = sourceFileInfo.CreateEncryptedName(); AxCryptDocument document = new AxCryptDocument(); IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(Path.Combine(_rootPath, "decrypted test.txt")); AxCryptDocument nullDocument = null; IRuntimeFileInfo nullFileInfo = null; AesKey nullKey = null; ProgressContext nullProgress = null; Passphrase nullPassphrase = null; Stream nullStream = null; string nullString = null; Action <Stream> nullStreamAction = null; Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(nullFileInfo, destinationFileInfo, new Passphrase("axcrypt"), AxCryptOptions.EncryptWithCompression, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, nullFileInfo, new Passphrase("axcrypt"), AxCryptOptions.EncryptWithCompression, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, destinationFileInfo, nullPassphrase, AxCryptOptions.EncryptWithCompression, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, destinationFileInfo, new Passphrase("axcrypt"), AxCryptOptions.EncryptWithCompression, nullProgress); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(nullFileInfo, new MemoryStream(), new AesKey(), AxCryptOptions.None, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, nullStream, new AesKey(), AxCryptOptions.None, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, new MemoryStream(), nullKey, AxCryptOptions.None, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, new MemoryStream(), new AesKey(), AxCryptOptions.None, nullProgress); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(nullDocument, decryptedFileInfo, AxCryptOptions.SetFileTimes, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(document, nullFileInfo, AxCryptOptions.SetFileTimes, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(document, decryptedFileInfo, AxCryptOptions.SetFileTimes, nullProgress); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(nullFileInfo, decryptedFileInfo, new AesKey(), AxCryptOptions.SetFileTimes, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, nullFileInfo, new AesKey(), AxCryptOptions.SetFileTimes, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, decryptedFileInfo, nullKey, AxCryptOptions.SetFileTimes, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, decryptedFileInfo, new AesKey(), AxCryptOptions.SetFileTimes, nullProgress); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(nullFileInfo, Path.Combine(_rootPath, "Directory"), new AesKey(), AxCryptOptions.SetFileTimes, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, nullString, new AesKey(), AxCryptOptions.SetFileTimes, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, Path.Combine(_rootPath, "Directory"), nullKey, AxCryptOptions.SetFileTimes, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, Path.Combine(_rootPath, "Directory"), new AesKey(), AxCryptOptions.SetFileTimes, nullProgress); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Document(nullFileInfo, new AesKey(), new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Document(sourceFileInfo, nullKey, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Document(sourceFileInfo, new AesKey(), nullProgress); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.WriteToFileWithBackup(null, (Stream stream) => { }, new ProgressContext()); }); IRuntimeFileInfo fileInfo = OS.Current.FileInfo(_testTextPath); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.WriteToFileWithBackup(fileInfo, nullStreamAction, new ProgressContext()); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.MakeAxCryptFileName(nullFileInfo); }); Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Wipe(nullFileInfo, new ProgressContext()); }); }
public static void TestInputStreamTooShort() { using (MemoryStream testStream = new MemoryStream()) { byte[] guid = AxCrypt1Guid.GetBytes(); testStream.Write(guid, 0, guid.Length); testStream.Position = 0; using (AxCryptDocument document = new AxCryptDocument()) { Assert.Throws <FileFormatException>(() => { document.Load(testStream, new Passphrase(String.Empty).DerivedPassphrase); }, "Calling with too short a stream, only containing a GUID."); } } }
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 TestFileNameFromSimpleFileWithUnicode() { 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 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 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 TestUncompressedEncryptedDecryptAxCrypt17() { IRuntimeFileInfo sourceRuntimeFileInfo = OS.Current.FileInfo(_uncompressedAxxPath); IRuntimeFileInfo destinationRuntimeFileInfo = OS.Current.FileInfo(Path.Combine(Path.GetDirectoryName(_uncompressedAxxPath), "Uncompressed.zip")); Passphrase passphrase = new Passphrase("Uncompressable"); using (AxCryptDocument document = new AxCryptDocument()) { bool isOk = document.Load(sourceRuntimeFileInfo.OpenRead(), passphrase.DerivedPassphrase); Assert.That(isOk, Is.True, "The document should load ok."); AxCryptFile.Decrypt(document, destinationRuntimeFileInfo, AxCryptOptions.None, new ProgressContext()); Assert.That(document.DocumentHeaders.UncompressedLength, Is.EqualTo(0), "Since the data is not compressed, there should not be a CompressionInfo, but in 1.x there is, with value zero."); } }
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."); } } }
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 TestEncryptToStream() { IRuntimeFileInfo sourceFileInfo = OS.Current.FileInfo(_testTextPath); IRuntimeFileInfo destinationFileInfo = sourceFileInfo.CreateEncryptedName(); Assert.That(destinationFileInfo.Name, Is.EqualTo("test-txt.axx"), "Wrong encrypted file name based on the plain text file name."); using (Stream destinationStream = destinationFileInfo.OpenWrite()) { AxCryptFile.Encrypt(sourceFileInfo, destinationStream, new Passphrase("axcrypt").DerivedPassphrase, AxCryptOptions.EncryptWithCompression, new ProgressContext()); } using (AxCryptDocument document = AxCryptFile.Document(destinationFileInfo, new Passphrase("axcrypt").DerivedPassphrase, new ProgressContext())) { Assert.That(document.PassphraseIsValid, Is.True, "The passphrase should be ok."); } }
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 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()); }); } } } }
private static ActiveFile CheckKeysForAlreadyDecryptedFile(ActiveFile destinationActiveFile, IEnumerable <AesKey> keys, ProgressContext progress) { foreach (AesKey key in keys) { using (AxCryptDocument document = AxCryptFile.Document(destinationActiveFile.EncryptedFileInfo, key, progress)) { if (document.PassphraseIsValid) { if (OS.Log.IsWarningEnabled) { OS.Log.LogWarning("File was already decrypted and the key was known for '{0}' to '{1}'".InvariantFormat(destinationActiveFile.EncryptedFileInfo.FullName, destinationActiveFile.DecryptedFileInfo.FullName)); } return(new ActiveFile(destinationActiveFile, key)); } } } return(null); }
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."); } } }
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 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 static FileOperationStatus OpenAndLaunchApplication(this FileSystemState fileSystemState, string file, AxCryptDocument document, ProgressContext progress) { if (fileSystemState == null) { throw new ArgumentNullException("fileSystemState"); } if (file == null) { throw new ArgumentNullException("file"); } if (document == null) { throw new ArgumentNullException("document"); } if (progress == null) { throw new ArgumentNullException("progress"); } IRuntimeFileInfo fileInfo = OS.Current.FileInfo(file); ActiveFile destinationActiveFile = fileSystemState.FindEncryptedPath(fileInfo.FullName); if (destinationActiveFile == null || !destinationActiveFile.DecryptedFileInfo.Exists) { IRuntimeFileInfo destinationFolderInfo = GetTemporaryDestinationFolder(destinationActiveFile); destinationActiveFile = DecryptActiveFileDocument(fileInfo, destinationFolderInfo, document, progress); } else { destinationActiveFile = new ActiveFile(destinationActiveFile, document.DocumentHeaders.KeyEncryptingKey); } fileSystemState.Add(destinationActiveFile); fileSystemState.Save(); FileOperationStatus status = LaunchApplicationForDocument(fileSystemState, destinationActiveFile); return status; }
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."); } } } } }
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 TestDecryptWithCancel() { IRuntimeFileInfo sourceFileInfo = OS.Current.FileInfo(_helloWorldAxxPath); using (AxCryptDocument document = new AxCryptDocument()) { Passphrase passphrase = new Passphrase("a"); using (Stream sourceStream = sourceFileInfo.OpenRead()) { bool keyIsOk = document.Load(sourceStream, passphrase.DerivedPassphrase); Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!"); IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(_rootPath.PathCombine("Destination", "Decrypted.txt")); ProgressContext progress = new ProgressContext(TimeSpan.Zero); progress.Progressing += (object sender, ProgressEventArgs e) => { throw new OperationCanceledException(); }; Assert.Throws<OperationCanceledException>(() => { AxCryptFile.Decrypt(document, destinationInfo, AxCryptOptions.None, progress); }); } } }
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()); }); } } } }
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 TestInputStreamTooShort() { using (MemoryStream testStream = new MemoryStream()) { byte[] guid = AxCrypt1Guid.GetBytes(); testStream.Write(guid, 0, guid.Length); testStream.Position = 0; using (AxCryptDocument document = new AxCryptDocument()) { Assert.Throws<FileFormatException>(() => { document.Load(testStream, new Passphrase(String.Empty).DerivedPassphrase); }, "Calling with too short a stream, only containing a GUID."); } } }
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 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 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 TestDecryptWithoutLoadFirstFromEmptyFile() { using (AxCryptDocument document = new AxCryptDocument()) { using (MemoryStream plaintextStream = new MemoryStream()) { Assert.Throws<InternalErrorException>(() => { document.DecryptTo(plaintextStream, new ProgressContext()); }); } } }
private static ActiveFile DecryptActiveFileDocument(IRuntimeFileInfo sourceFileInfo, IRuntimeFileInfo destinationFolderInfo, AxCryptDocument document, ProgressContext progress) { string destinationName = document.DocumentHeaders.FileName; string destinationPath = Path.Combine(destinationFolderInfo.FullName, destinationName); IRuntimeFileInfo destinationFileInfo = OS.Current.FileInfo(destinationPath); using (FileLock fileLock = FileLock.Lock(destinationFileInfo)) { AxCryptFile.Decrypt(document, destinationFileInfo, AxCryptOptions.SetFileTimes, progress); } ActiveFile destinationActiveFile = new ActiveFile(sourceFileInfo, destinationFileInfo, document.DocumentHeaders.KeyEncryptingKey, ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.IgnoreChange, null); if (OS.Log.IsInfoEnabled) { OS.Log.LogInfo("File decrypted from '{0}' to '{1}'".InvariantFormat(sourceFileInfo.FullName, destinationActiveFile.DecryptedFileInfo.FullName)); } return destinationActiveFile; }
public static void TestEncryptFileWhenDestinationExists() { IRuntimeFileInfo sourceInfo = OS.Current.FileInfo(_davidCopperfieldTxtPath); IRuntimeFileInfo expectedDestinationInfo = OS.Current.FileInfo(AxCryptFile.MakeAxCryptFileName(sourceInfo)); using (Stream stream = expectedDestinationInfo.OpenWrite()) { } FileOperationsController controller = new FileOperationsController(_fileSystemState); string destinationPath = String.Empty; controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) => { e.Passphrase = "allan"; }; controller.QuerySaveFileAs += (object sender, FileOperationEventArgs e) => { e.SaveFileFullName = Path.Combine(Path.GetDirectoryName(e.SaveFileFullName), "alternative-name.axx"); }; controller.Completed += (object sender, FileOperationEventArgs e) => { destinationPath = e.SaveFileFullName; }; FileOperationStatus status = controller.EncryptFile(_davidCopperfieldTxtPath); Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success."); Assert.That(Path.GetFileName(destinationPath), Is.EqualTo("alternative-name.axx"), "The alternative name should be used, since the default existed."); IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath); Assert.That(destinationInfo.Exists, "After encryption the destination file should be created."); using (AxCryptDocument document = new AxCryptDocument()) { using (Stream stream = destinationInfo.OpenRead()) { document.Load(stream, new Passphrase("allan").DerivedPassphrase); Assert.That(document.PassphraseIsValid, "The encrypted document should be valid and encrypted with the passphrase given."); } } }
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 TestSimpleEncryptFileOnThreadWorker() { FileOperationsController controller = new FileOperationsController(_fileSystemState); controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) => { e.Passphrase = "allan"; }; string destinationPath = String.Empty; FileOperationStatus status = FileOperationStatus.Unknown; controller.Completed += (object sender, FileOperationEventArgs e) => { destinationPath = e.SaveFileFullName; status = e.Status; }; using (ThreadWorker worker = new ThreadWorker(new ProgressContext())) { controller.EncryptFile(_davidCopperfieldTxtPath, worker); worker.Join(); } Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success."); IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath); Assert.That(destinationInfo.Exists, "After encryption the destination file should be created."); using (AxCryptDocument document = new AxCryptDocument()) { using (Stream stream = destinationInfo.OpenRead()) { document.Load(stream, new Passphrase("allan").DerivedPassphrase); Assert.That(document.PassphraseIsValid, "The encrypted document should be valid and encrypted with the passphrase given."); } } }