public void TestDecryptCompressedWithTruncatedFile() { Passphrase passphrase = new Passphrase("Å ä Ö"); using (V1AxCryptDocument document = new V1AxCryptDocument()) { using (MemoryStream encryptedFile = FakeDataStore.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt)) { encryptedFile.SetLength(encryptedFile.Length / 2); encryptedFile.Position = 0; bool keyIsOk = document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, encryptedFile); Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!"); using (MemoryStream plaintextStream = new MemoryStream()) { Assert.That(() => { document.DecryptTo(plaintextStream); }, Throws.InstanceOf <Exception>()); } } } }
/// <summary> /// Tries to load a key pair from the serialized byte array. /// </summary> /// <param name="value">The bytes.</param> /// <param name="passphrase">The passphrase.</param> /// <param name="keyPair">The key pair.</param> /// <returns>True if the pair was successfully loaded, and set in the keyPair parameter.</returns> public static bool TryLoad(byte[] value, Passphrase passphrase, out UserKeyPair keyPair) { using (MemoryStream encryptedStream = new MemoryStream(value)) { using (MemoryStream decryptedStream = new MemoryStream()) { EncryptedProperties properties = New <AxCryptFile>().Decrypt(encryptedStream, decryptedStream, new DecryptionParameter[] { new DecryptionParameter(passphrase, Resolve.CryptoFactory.Preferred.CryptoId) }); if (!properties.IsValid) { keyPair = null; return(false); } string json = Encoding.UTF8.GetString(decryptedStream.ToArray(), 0, (int)decryptedStream.Length); keyPair = Resolve.Serializer.Deserialize <UserKeyPair>(json); return(true); } } }
public void TestDecryptCompressedFromLargerFile() { Passphrase passphrase = new Passphrase("Å ä Ö"); using (V1AxCryptDocument document = new V1AxCryptDocument()) { bool keyIsOk = document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, FakeDataStore.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt)); Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!"); using (MemoryStream plaintextStream = new MemoryStream()) { document.DecryptTo(plaintextStream); string text = Encoding.UTF8.GetString(plaintextStream.GetBuffer(), 0, (int)plaintextStream.Length); Assert.That(text.StartsWith("The Project Gutenberg EBook of David Copperfield, by Charles Dickens"), "Unexpected start of David Copperfield."); Assert.That(text.EndsWith("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 TestDecryptCompressedWithCancel() { 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()) { 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 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 async Task TestWatchedFoldersWhenLoggedOn() { Passphrase key1 = new Passphrase("a"); LogOnIdentity key2 = new LogOnIdentity("b"); KnownIdentities knownIdentities = new KnownIdentities(Resolve.FileSystemState, Resolve.SessionNotify); FakeDataStore.AddFolder(@"C:\WatchedFolder1\"); FakeDataStore.AddFolder(@"C:\WatchedFolder2\"); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\WatchedFolder1\", new LogOnIdentity(key1).Tag)); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\WatchedFolder2\", key2.Tag)); await knownIdentities.SetDefaultEncryptionIdentity(key2); IEnumerable <WatchedFolder> watchedFolders = knownIdentities.LoggedOnWatchedFolders; Assert.That(watchedFolders.Count(), Is.EqualTo(1), "Only one of the two watched folders should be shown."); Assert.That(watchedFolders.First().Tag.Matches(key2.Tag), "The returned watched folder should be number 2."); }
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 async Task TestLogOnExistingIdentity() { Passphrase passphrase = new Passphrase("p"); Passphrase id = passphrase; Resolve.FileSystemState.KnownPassphrases.Add(id); IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify); ivm.LoggingOnAsync = (e) => { e.Passphrase = new Passphrase("p"); return(Task.FromResult <object>(null)); }; await ivm.LogOnLogOff.ExecuteAsync(null); Assert.That(Resolve.KnownIdentities.IsLoggedOn); }
public async Task AskForLogOnPassphraseWithKnownIdentityButWrongPassphraseEntered() { Passphrase passphrase = new Passphrase("aaa"); Passphrase id = passphrase; Resolve.FileSystemState.KnownPassphrases.Add(id); IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify); ivm.LoggingOnAsync = (e) => { e.Passphrase = new Passphrase("bbb"); return(Task.FromResult <object>(null)); }; await ivm.AskForLogOnPassphrase.ExecuteAsync(null); Assert.That(ivm.LogOnIdentity == LogOnIdentity.Empty); Assert.That(Resolve.FileSystemState.KnownPassphrases.Count(), Is.EqualTo(1)); }
public async Task <bool> ChangePassphraseAsync(Passphrase passphrase) { if (New <AxCryptOnlineState>().IsOnline) { try { return(await _remoteService.ChangePassphraseAsync(passphrase).Free()); } catch (UnauthorizedException uaex) { New <IReport>().Exception(uaex); return(false); } catch (ApiException aex) { await aex.HandleApiExceptionAsync(); } } return(await _localService.ChangePassphraseAsync(passphrase).Free()); }
/// <summary> /// Loads an AxCrypt file from the specified reader. After this, the reader is positioned to /// read encrypted data. /// </summary> /// <param name="passphrase">The passphrase.</param> /// <param name="cryptoId">The crypto identifier.</param> /// <param name="reader">The reader.</param> /// <param name="headers">The headers.</param> /// <returns> /// True if the key was valid, false if it was wrong. /// </returns> private bool Load(Passphrase passphrase, Guid cryptoId, AxCryptReader reader, Headers headers) { ResetState(); if (cryptoId == new V1Aes128CryptoFactory().CryptoId) { return(PassphraseIsValid); } _reader = reader; CryptoFactory = Resolve.CryptoFactory.Create(cryptoId); V2KeyWrapHeaderBlock keyWrap = headers.FindHeaderBlock <V2KeyWrapHeaderBlock>(); IDerivedKey key = CryptoFactory.RestoreDerivedKey(passphrase, keyWrap.DerivationSalt, keyWrap.DerivationIterations); keyWrap.SetDerivedKey(CryptoFactory, key); DocumentHeaders = new V2DocumentHeaders(keyWrap); PassphraseIsValid = DocumentHeaders.Load(headers); Properties = EncryptedProperties.Create(this); return(PassphraseIsValid); }
public static void TestCheckActiveFilesKeyIsNotSetWithoutKnownKey() { DateTime utcNow = OS.Current.UtcNow; FakeRuntimeFileInfo.AddFile(_encryptedFile1, utcNow, utcNow, utcNow, FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt)); Passphrase passphrase = new Passphrase("a"); AxCryptFile.Decrypt(OS.Current.FileInfo(_encryptedFile1), OS.Current.FileInfo(_decryptedFile1), passphrase.DerivedPassphrase, AxCryptOptions.None, new ProgressContext()); ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedFile1), OS.Current.FileInfo(_decryptedFile1), passphrase.DerivedPassphrase, ActiveFileStatus.AssumedOpenAndDecrypted, null); _fileSystemState.Add(activeFile); _fileSystemState.Save(); _fileSystemState.Dispose(); _fileSystemState = new FileSystemState(); _fileSystemState.Load(OS.Current.FileInfo(_fileSystemStateFilePath)); IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_decryptedFile1); decryptedFileInfo.SetFileTimes(utcNow.AddSeconds(30), utcNow.AddSeconds(30), utcNow.AddSeconds(30)); SetupAssembly.FakeRuntimeEnvironment.TimeFunction = (() => { return(utcNow.AddMinutes(1)); }); bool changedWasRaised = false; _fileSystemState.Changed += ((object sender, ActiveFileChangedEventArgs e) => { changedWasRaised = true; }); activeFile = _fileSystemState.FindEncryptedPath(_encryptedFile1); Assert.That(activeFile.Key, Is.Null, "The key should be null after loading of new FileSystemState"); _fileSystemState.CheckActiveFiles(ChangedEventMode.RaiseOnlyOnModified, new ProgressContext()); Assert.That(changedWasRaised, Is.False, "The ActiveFile should be not be modified because the file was modified as well and thus cannot be deleted."); activeFile = _fileSystemState.FindEncryptedPath(_encryptedFile1); Assert.That(activeFile.Key, Is.Null, "The key should still be null after the checking of active files."); Assert.That(activeFile.Status.HasMask(ActiveFileStatus.AssumedOpenAndDecrypted), Is.True, "The file should still be there."); Assert.That(activeFile.ThumbprintMatch(passphrase.DerivedPassphrase), Is.True, "The active file should still be known to be decryptable with the original passphrase."); }
private static string DecryptPrivateKeyPem(string privateEncryptedPem, Passphrase passphrase) { if (privateEncryptedPem.Length == 0) { return(String.Empty); } byte[] privateKeyEncryptedPem = Convert.FromBase64String(privateEncryptedPem); byte[] decryptedPrivateKeyBytes = New <IProtectedData>().Unprotect(privateKeyEncryptedPem, null); if (decryptedPrivateKeyBytes != null) { return(Encoding.UTF8.GetString(decryptedPrivateKeyBytes, 0, decryptedPrivateKeyBytes.Length)); } if (passphrase == Passphrase.Empty) { return(null); } using (MemoryStream encryptedPrivateKeyStream = new MemoryStream(privateKeyEncryptedPem)) { using (MemoryStream decryptedPrivateKeyStream = new MemoryStream()) { DecryptionParameter decryptionParameter = new DecryptionParameter(passphrase, Resolve.CryptoFactory.Preferred.CryptoId); try { if (!New <AxCryptFile>().Decrypt(encryptedPrivateKeyStream, decryptedPrivateKeyStream, new DecryptionParameter[] { decryptionParameter }).IsValid) { return(null); } } catch (FileFormatException ffex) { New <IReport>().Exception(ffex); return(null); } return(Encoding.UTF8.GetString(decryptedPrivateKeyStream.ToArray(), 0, (int)decryptedPrivateKeyStream.Length)); } } }
private async Task ImportFileActionAsync() { IDataStore privateKeyData = New <IDataStore>(PrivateKeyFileName); Passphrase passphrase = new Passphrase(PasswordText); UserKeyPair keyPair; if (!UserKeyPair.TryLoad(privateKeyData.ToArray(), passphrase, out keyPair)) { ImportSuccessful = false; return; } LogOnIdentity identity = new LogOnIdentity(keyPair.UserEmail, passphrase); AccountStorage store = new AccountStorage(New <LogOnIdentity, IAccountService>(identity)); await store.ImportAsync(keyPair); ImportSuccessful = true; _userSettings.UserEmail = keyPair.UserEmail.Address; await _knownIdentities.SetDefaultEncryptionIdentity(new LogOnIdentity(await store.AllKeyPairsAsync(), passphrase)); }
public async Task AskForNewLogOnPassphraseAutomaticallyBecauseNoIdentitiesExists() { Resolve.FileSystemState.KnownPassphrases.Add(Passphrase.Create("aaa")); IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify); ivm.LoggingOnAsync = (e) => { e.Passphrase = new Passphrase("aaa"); e.Name = "New User Passphrase"; return(Task.FromResult <object>(null)); }; await ivm.AskForLogOnPassphrase.ExecuteAsync(LogOnIdentity.Empty); Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("aaa")); Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(new Passphrase("aaa").Thumbprint)); Passphrase id = Resolve.FileSystemState.KnownPassphrases.FirstOrDefault(i => i.Thumbprint == new Passphrase("aaa").Thumbprint); Assert.That(id.Thumbprint, Is.EqualTo(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint)); }
public async Task TestLogOnLogOffWhenLoggedOffAndNoIdentities() { bool wasCreateNew = true; IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify); ivm.LoggingOnAsync = (e) => { wasCreateNew = e.IsAskingForPreviouslyUnknownPassphrase; e.Passphrase = new Passphrase("ccc"); e.Name = "New User Passphrase"; return(Task.FromResult <object>(null)); }; Resolve.FileSystemState.KnownPassphrases.Add(Passphrase.Create("ccc")); await ivm.LogOnLogOff.ExecuteAsync(null); Assert.That(wasCreateNew, Is.False, "Logging on event should not be with Create New set."); Assert.That(Resolve.KnownIdentities.IsLoggedOn, Is.True, "Should be logged on."); Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(new Passphrase("ccc").Thumbprint)); Assert.That(Resolve.FileSystemState.KnownPassphrases.Count(), Is.EqualTo(1)); }
public void TestDecryptCompressedWithCancel() { Passphrase passphrase = new Passphrase("Å ä Ö"); using (V1AxCryptDocument document = new V1AxCryptDocument()) { IProgressContext progress = new CancelProgressContext(new ProgressContext(new TimeSpan(0, 0, 0, 0, 100))); bool keyIsOk = document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, new ProgressStream(FakeDataStore.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt), progress)); Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!"); using (MemoryStream plaintextStream = new MemoryStream()) { progress.Progressing += (object sender, ProgressEventArgs e) => { progress.Cancel = true; }; FakeRuntimeEnvironment environment = (FakeRuntimeEnvironment)OS.Current; environment.CurrentTiming.CurrentTiming = new TimeSpan(0, 0, 0, 0, 100); Assert.Throws <OperationCanceledException>(() => { document.DecryptTo(plaintextStream); }); } } }
public async Task AskForLogOnPassphraseWithKnownIdentity() { Passphrase passphrase = new Passphrase("aaa"); Passphrase id = passphrase; Resolve.FileSystemState.KnownPassphrases.Add(id); IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify); ivm.LoggingOnAsync = (e) => { e.Passphrase = new Passphrase("aaa"); return(Task.FromResult <object>(null)); }; await ivm.AskForLogOnPassphrase.ExecuteAsync(null); Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("aaa")); Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(passphrase.Thumbprint)); Assert.That(Resolve.FileSystemState.KnownPassphrases.Count(), Is.EqualTo(1)); }
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 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()); }); } } } }
private async Task <LogOnIdentity> AddKnownIdentityFromEventAsync(LogOnEventArgs logOnArgs) { if (logOnArgs.Cancel || logOnArgs.Passphrase == Passphrase.Empty) { return(LogOnIdentity.Empty); } _userSettings.DisplayEncryptPassphrase = logOnArgs.DisplayPassphrase; Passphrase passphrase = logOnArgs.Passphrase; LogOnIdentity identity = await LogOnIdentityFromCredentialsAsync(EmailAddress.Parse(logOnArgs.UserEmail), passphrase); if (identity == LogOnIdentity.Empty) { identity = new LogOnIdentity(passphrase); _fileSystemState.KnownPassphrases.Add(passphrase); await _fileSystemState.Save(); } await _knownIdentities.AddAsync(identity); return(identity); }
/// <summary> /// Loads an AxCrypt file from the specified reader. After this, the reader is positioned to /// read encrypted data. /// </summary> /// <param name="inputStream">The stream to read from. Will be disposed when this instance is disposed.</param> /// <returns>True if the key was valid, false if it was wrong.</returns> private bool Load(Passphrase passphrase, AxCryptReader reader, Headers headers) { _reader = reader; ResetState(passphrase); PassphraseIsValid = DocumentHeaders.Load(headers); if (!PassphraseIsValid) { return(false); } _hmacStream = new V1HmacStream(DocumentHeaders.HmacSubkey.Key); foreach (HeaderBlock header in DocumentHeaders.Headers.HeaderBlocks) { if (header.HeaderBlockType != HeaderBlockType.Preamble) { header.Write(_hmacStream); } } Properties = EncryptedProperties.Create(this); return(true); }
public void TestSimpleEncryptToWithCompression() { 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 = FakeDataStore.ExpandableMemoryStream(Encoding.UTF8.GetBytes("AxCrypt is Great!"))) { using (Stream outputStream = new MemoryStream()) { Passphrase passphrase = new Passphrase("a"); using (V1AxCryptDocument document = new V1AxCryptDocument(passphrase, 47)) { document.DocumentHeaders.FileName = "MyFile.txt"; document.DocumentHeaders.CreationTimeUtc = creationTimeUtc; document.DocumentHeaders.LastAccessTimeUtc = lastAccessTimeUtc; document.DocumentHeaders.LastWriteTimeUtc = lastWriteTimeUtc; document.EncryptTo(inputStream, outputStream, AxCryptOptions.EncryptWithCompression); } outputStream.Position = 0; using (V1AxCryptDocument document = new V1AxCryptDocument()) { bool keyIsOk = document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, outputStream); 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); Assert.That(document.DocumentHeaders.UncompressedLength, Is.EqualTo(17), "'AxCrypt is Great!' should be 17 bytes uncompressed plaintext."); Assert.That(Encoding.ASCII.GetString(plaintextStream.GetBuffer(), 0, (int)plaintextStream.Length), Is.EqualTo("AxCrypt is Great!"), "Unexpected result of decryption."); } } } } }
public V1DocumentHeaders(Passphrase passphrase, long keyWrapIterations) : this(passphrase) { _headers.HeaderBlocks.Add(new PreambleHeaderBlock()); _headers.HeaderBlocks.Add(new VersionHeaderBlock(_version)); _headers.HeaderBlocks.Add(new V1KeyWrap1HeaderBlock(_keyEncryptingKey.DerivedKey, keyWrapIterations)); ICrypto headerCrypto = Resolve.CryptoFactory.Legacy.CreateCrypto(HeadersSubkey.Key, null, 0); _headers.HeaderBlocks.Add(new V1EncryptionInfoEncryptedHeaderBlock(headerCrypto)); _headers.HeaderBlocks.Add(new V1CompressionEncryptedHeaderBlock(headerCrypto)); _headers.HeaderBlocks.Add(new FileInfoEncryptedHeaderBlock(headerCrypto)); _headers.HeaderBlocks.Add(new V1UnicodeFileNameInfoEncryptedHeaderBlock(headerCrypto)); _headers.HeaderBlocks.Add(new V1FileNameInfoEncryptedHeaderBlock(headerCrypto)); _headers.HeaderBlocks.Add(new DataHeaderBlock()); SetMasterKeyForEncryptedHeaderBlocks(_headers.HeaderBlocks); V1EncryptionInfoEncryptedHeaderBlock encryptionInfoHeaderBlock = _headers.FindHeaderBlock <V1EncryptionInfoEncryptedHeaderBlock>(); encryptionInfoHeaderBlock.IV = new SymmetricIV(128); encryptionInfoHeaderBlock.PlaintextLength = 0; FileName = String.Empty; }
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 void TestDecryptUncompressedWithPaddingError() { Passphrase passphrase = new Passphrase("a"); using (V1AxCryptDocument document = new V1AxCryptDocument()) { using (MemoryStream encryptedFile = FakeDataStore.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(passphrase, new V1Aes128CryptoFactory().CryptoId, encryptedFile); Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!"); using (MemoryStream plaintextStream = new MemoryStream()) { Assert.Throws <CryptoException>(() => { document.DecryptTo(plaintextStream); }); } } } }
protected override async Task ProcessRequestAsync(IHttpWebRequest request, Dictionary <string, object> payload) { if (CanMakeAuthenticatedRequest(payload)) { if (payload.TryGetValue("body", out var body)) { payload.Remove("body"); } var nonce = payload["nonce"].ToString(); payload.Remove("nonce"); var json = JsonConvert.SerializeObject(body ?? payload); if (json == "{}") { json = ""; } var passphrase = Passphrase?.ToUnsecureString(); if (string.IsNullOrEmpty(passphrase)) { passphrase = PrivateApiKey?.ToUnsecureString(); } var hexSha384 = CryptoUtility.SHA384Sign( $"{request.RequestUri.PathAndQuery.Replace("/spot", string.Empty)}{nonce}{json}", passphrase); request.AddHeader("btse-sign", hexSha384); request.AddHeader("btse-nonce", nonce); request.AddHeader("btse-api", PublicApiKey.ToUnsecureString()); await request.WriteToRequestAsync(json); } await base.ProcessRequestAsync(request, payload); }
public async Task <Result> Restore(Passphrase passphrase) { var keyPair = new KeyPair ( PublicKey, new PrivateKey(backup.EncryptedPrivateKey) ); if (IsInCache) { Debug.Assert(passphrase != null); if (!keyPair.CanUnlockWith(passphrase)) { return(false); } } var identity = await Engine.ImportIdentity(backup.Stereotype, Name, keyPair); Main.CurrentIdentity = (IdentityVM)identity; return(true); }
public async Task AskForNewLogOnPassphraseWithCancel() { Passphrase defaultPassphrase = null; Resolve.FileSystemState.KnownPassphrases.Add(Passphrase.Empty); IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify); bool isCancelling = false; ivm.LoggingOnAsync = (e) => { if (isCancelling) { e.Cancel = true; return(Task.FromResult <object>(null)); } if (!e.IsAskingForPreviouslyUnknownPassphrase) { e.IsAskingForPreviouslyUnknownPassphrase = true; e.Passphrase = new Passphrase("xxx"); return(Task.FromResult <object>(null)); } defaultPassphrase = e.Passphrase; e.Cancel = isCancelling = true; return(Task.FromResult <object>(null)); }; await ivm.AskForLogOnPassphrase.ExecuteAsync(null); Assert.That(defaultPassphrase, Is.EqualTo(new Passphrase("xxx"))); Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity == LogOnIdentity.Empty); Assert.That(ivm.LogOnIdentity == LogOnIdentity.Empty); Passphrase id = Resolve.FileSystemState.KnownPassphrases.FirstOrDefault(i => i.Thumbprint == new Passphrase("xxx").Thumbprint); Assert.That(id, Is.Null); }
public void TestHmacThrowsWhenTooLittleData() { using (MemoryStream plaintext = new MemoryStream(Resources.uncompressable_zip)) { MemoryStream encryptedFile = new MemoryStream(); using (V1AxCryptDocument encryptingDocument = new V1AxCryptDocument(new Passphrase("a"), 10)) { encryptingDocument.EncryptTo(plaintext, encryptedFile, AxCryptOptions.EncryptWithoutCompression); } encryptedFile.Position = 0; Headers headers = new Headers(); AxCryptReader reader = headers.CreateReader(new LookAheadStream(encryptedFile)); using (V1AxCryptDocument document = new V1AxCryptDocument(reader)) { Passphrase key = new Passphrase("a"); bool keyIsOk = document.Load(key, new V1Aes128CryptoFactory().CryptoId, headers); Assert.That(keyIsOk, Is.True); reader.InputStream.Read(new byte[16], 0, 16); Assert.Throws <InvalidOperationException>(() => document.DecryptTo(Stream.Null)); } } }