public static async Task<IRandomAccessStream> ConvertToRandomAccessStream(Stream source) { Stream streamToConvert = null; if (!source.CanRead) throw new Exception("The source cannot be read."); if (!source.CanSeek) { var memStream = new MemoryStream(); await source.CopyToAsync(memStream); streamToConvert = memStream; } else { streamToConvert = source; } var reader = new DataReader(streamToConvert.AsInputStream()); streamToConvert.Position = 0; await reader.LoadAsync((uint) streamToConvert.Length); var buffer = reader.ReadBuffer((uint) streamToConvert.Length); var randomAccessStream = new InMemoryRandomAccessStream(); var outputStream = randomAccessStream.GetOutputStreamAt(0); await outputStream.WriteAsync(buffer); await outputStream.FlushAsync(); return randomAccessStream; }
public async static Task<IRandomAccessStream> AsRandomAccessStreamAsync(this Stream stream) { Stream streamToConvert = null; if (!stream.CanRead) { throw new Exception("Cannot read the source stream-"); } if (!stream.CanSeek) { MemoryStream memoryStream = new MemoryStream(); await stream.CopyToAsync(memoryStream); streamToConvert = memoryStream; } else { streamToConvert = stream; } DataReader dataReader = new DataReader(streamToConvert.AsInputStream()); streamToConvert.Position = 0; await dataReader.LoadAsync((uint)streamToConvert.Length); IBuffer buffer = dataReader.ReadBuffer((uint)streamToConvert.Length); InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream(); IOutputStream outputstream = randomAccessStream.GetOutputStreamAt(0); await outputstream.WriteAsync(buffer); await outputstream.FlushAsync(); return randomAccessStream; }
private async void ProtectData() { if (await storageFolder.TryGetItemAsync("config.txt") != null) // if user file exists { configSF = await storageFolder.GetFileAsync("config.txt"); var stream = await configSF.OpenAsync(Windows.Storage.FileAccessMode.Read); ulong size = stream.Size; using (var inputStream = stream.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream)) { uint numBytesLoaded = await dataReader.LoadAsync((uint)size); IBuffer textBuffer = dataReader.ReadBuffer(numBytesLoaded); string text = await SampleDataUnprotectStream(textBuffer, encoding); if (text.Length != 0 && text.IndexOf(" ") > 0) { Username.Text = text.Substring(0, text.IndexOf(" ")); Password.Password = text.Substring(text.IndexOf(" ") + 1); saveLogin = true; SavePasswordCheckBox.IsChecked = true; } } } } }
public async Task<string> Decrypt(IBuffer buffProtected, BinaryStringEncoding encoding) { try { // Create a DataProtectionProvider object. DataProtectionProvider Provider = new DataProtectionProvider(); // Create a random access stream to contain the encrypted message. InMemoryRandomAccessStream inputData = new InMemoryRandomAccessStream(); // Create a random access stream to contain the decrypted data. InMemoryRandomAccessStream unprotectedData = new InMemoryRandomAccessStream(); // Retrieve an IOutputStream object and fill it with the input (encrypted) data. IOutputStream outputStream = inputData.GetOutputStreamAt(0); DataWriter writer = new DataWriter(outputStream); writer.WriteBuffer(buffProtected); await writer.StoreAsync(); await outputStream.FlushAsync(); // Retrieve an IInputStream object from which you can read the input (encrypted) data. IInputStream source = inputData.GetInputStreamAt(0); // Retrieve an IOutputStream object and fill it with decrypted data. IOutputStream dest = unprotectedData.GetOutputStreamAt(0); await Provider.UnprotectStreamAsync(source, dest); await dest.FlushAsync(); // Write the decrypted data to an IBuffer object. DataReader reader2 = new DataReader(unprotectedData.GetInputStreamAt(0)); await reader2.LoadAsync((uint)unprotectedData.Size); IBuffer buffUnprotectedData = reader2.ReadBuffer((uint)unprotectedData.Size); // Convert the IBuffer object to a string using the same encoding that was // used previously to conver the plaintext string (before encryption) to an // IBuffer object. String strUnprotected = CryptographicBuffer.ConvertBinaryToString(encoding, buffUnprotectedData); // Return the decrypted data. return strUnprotected; } catch (Exception ex) { App.Telemetry.TrackException(ex); return ""; } }
public async Task SaveBitmapAsync(string albumFolder, uint size, string songPath) { var songFile = await StorageFile.GetFileFromPathAsync(songPath); using (var thumbnail = await songFile.GetThumbnailAsync(ThumbnailMode.MusicView, size) ?? await songFile.GetThumbnailAsync(ThumbnailMode.VideosView, size)) { if (thumbnail == null) return; var reader = new DataReader(thumbnail); var fileLength = (uint)thumbnail.Size; await reader.LoadAsync(fileLength); var buffer = reader.ReadBuffer(fileLength); var memStream = new InMemoryRandomAccessStream(); await memStream.WriteAsync(buffer); await memStream.FlushAsync(); memStream.Seek(0); await ApplicationData.Current.LocalFolder.CreateFolderAsync(AlbumArtFolderName(albumFolder), CreationCollisionOption.OpenIfExists); var albumArtFileName = AlbumArtFileName(albumFolder, size); var outputFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(albumArtFileName, CreationCollisionOption.ReplaceExisting); // http://social.msdn.microsoft.com/Forums/windowsapps/en-US/1dda3a15-d299-40e0-b668-ec690a683f6e/how-to-resize-an-image-as-storagefile?forum=winappswithcsharp var decoder = await BitmapDecoder.CreateAsync(memStream); var transform = new BitmapTransform { ScaledHeight = size, ScaledWidth = size }; var pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); using (var destinationStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite)) { BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, destinationStream); encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, size, size, 96, 96, pixelData.DetachPixelData()); await encoder.FlushAsync(); } } }
/// <summary> /// Write the contents of stream to filename in the cache location. If a null stream is provided, the file is created with no contents. /// </summary> /// <param name="stream">Content to be written to file</param> /// <param name="filename">Name of the file to be written in cache location</param> private static async Task WriteFileAsync(Stream stream, string filename) { // Prepare output file stream StorageFolder parent = GetCacheFolder(); StorageFile file = null; try { file = await parent.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); } catch (Exception) { } if (file != null && stream != null) { // Prepare input image stream IInputStream inStream = stream.AsInputStream(); DataReader reader = new DataReader(inStream); IRandomAccessStream fileStream = null; try { fileStream = await file.OpenAsync(FileAccessMode.ReadWrite); // Buffered write to file await reader.LoadAsync(1024); while (reader.UnconsumedBufferLength > 0) { await fileStream.WriteAsync(reader.ReadBuffer(reader.UnconsumedBufferLength)); await reader.LoadAsync(1024); } } catch (Exception) { } finally { if (fileStream != null) { fileStream.FlushAsync(); } } inStream.Dispose(); } }
private async static Task <bool> SaveStreamTo3MF(Windows.Storage.Streams.IRandomAccessStream stream) { // set back stream.Seek(0); using (var dataReader = new Windows.Storage.Streams.DataReader(stream)) { var dataLoad = await dataReader.LoadAsync((uint)stream.Size); if (dataLoad > 0) { var buffer = dataReader.ReadBuffer((uint)stream.Size); StorageFolder localFolder = ApplicationData.Current.LocalFolder; var outputfile = await localFolder.CreateFileAsync("output.3mf", CreationCollisionOption.ReplaceExisting); await Windows.Storage.FileIO.WriteBufferAsync(outputfile, buffer); var options = new Windows.System.LauncherOptions(); options.TargetApplicationPackageFamilyName = "Microsoft.3DBuilder_8wekyb3d8bbwe"; } } return(true); }
private async void UnprotectAsyncBuffer_Click(object sender, RoutedEventArgs e) { string outputStr = ""; if (m_protectedStream != null) { IInputStream source = m_protectedStream.GetInputStreamAt(0); m_unprotectedStream = new InMemoryRandomAccessStream(); await DataProtectionManager.UnprotectStreamAsync(source, m_unprotectedStream ); var unprotectedReader = new DataReader(m_unprotectedStream.GetInputStreamAt(0)); await unprotectedReader.LoadAsync((uint)m_unprotectedStream.Size); IBuffer unprotectedStreamBuffer = unprotectedReader.ReadBuffer((uint)m_unprotectedStream.Size); outputStr += "\n UnProtected Stream buffer:" + CryptographicBuffer.EncodeToHexString(unprotectedStreamBuffer); rootPage.NotifyUser(outputStr, NotifyType.StatusMessage); } else { rootPage.NotifyUser("Please protect a stream to unprotect", NotifyType.ErrorMessage); } }
public async Task<bool> DownloadFileAsync(string ftpFile, string localFile, Boolean resume) { CheckLoggedIn(); var response = await ExecuteAsync("TYPE I"); response.CheckReturnCode(200); Debug.WriteLine("Downloading file " + ftpFile + " from " + HostName + "/" + WorkingDirectory, "FtpClient"); if (string.IsNullOrEmpty(localFile)) { localFile = ftpFile; } var tempFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(localFile, CreationCollisionOption.OpenIfExists); var tempStream = await tempFile.OpenStreamForWriteAsync(); StreamSocket dataSocket = await OpenSocketForTransferAsync(); ulong resumeOffset = 0; if (resume) { var prop = await tempFile.GetBasicPropertiesAsync(); resumeOffset = prop.Size; if (resumeOffset > 0) { response = await ExecuteAsync("REST " + resumeOffset); if (response.ReturnCode != 350) { resumeOffset = 0; Debug.WriteLine("Resuming not supported:" + response.Message, "FtpClient"); } else { Debug.WriteLine("Resuming at offset " + resumeOffset, "FtpClient"); tempStream.Seek(Convert.ToInt64(resumeOffset), SeekOrigin.Begin); } } } response = await ExecuteAsync("RETR " + ftpFile); response.CheckReturnCode(150, 125); var reader = new DataReader(dataSocket.InputStream); reader.InputStreamOptions = InputStreamOptions.Partial; var writer = new DataWriter(tempStream.AsOutputStream()); DateTime timeout = DateTime.Now.AddSeconds(TimeOut); while (timeout > DateTime.Now) { var count = await reader.LoadAsync(BUFFER_SIZE); var bytes = reader.ReadBuffer(count); writer.WriteBuffer(bytes); await writer.StoreAsync(); if (count < BUFFER_SIZE) { break; } } await tempStream.FlushAsync(); dataSocket.Dispose(); response = await ReadResponseAsync(); response.CheckReturnCode(226, 250); var props = await tempFile.GetBasicPropertiesAsync(); var tempSize = props.Size; var size = await GetFileSizeAsync(ftpFile); if (tempSize != size) return false; var destFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(localFile, CreationCollisionOption.ReplaceExisting); var destStream = await destFile.OpenStreamForWriteAsync(); tempStream.Seek(0, SeekOrigin.Begin); await tempStream.CopyToAsync(destStream); await destStream.FlushAsync(); await tempFile.DeleteAsync(StorageDeleteOption.PermanentDelete); return true; }
private static async Task<int> DoReadAsync(IInputStream stream, byte[] buffer, int offset, int count) { try { using (var reader = new DataReader(stream)) { await reader.LoadAsync((uint)count).AsTask().ConfigureAwait(false); var length = Math.Min((int)reader.UnconsumedBufferLength, count); reader.ReadBuffer((uint)length).CopyTo(0, buffer, offset, length); reader.DetachStream(); return length; } } catch { return 0; } }
private async Task<StorageFile> SaveTemporaryPhotoAsync(FilteredPhotoModel photo) { var filename = Application.Current.Resources["PhotoSaveTemporaryFilename"] as string; var folder = ApplicationData.Current.TemporaryFolder; var task = folder.CreateFileAsync(filename, Windows.Storage.CreationCollisionOption.ReplaceExisting).AsTask(); task.Wait(); var file = task.Result; CachedFileManager.DeferUpdates(file); using (var fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)) using (var photoStream = await photo.GetFilteredPhotoAsync()) using (var reader = new DataReader(photoStream)) using (var writer = new DataWriter(fileStream)) { await reader.LoadAsync((uint)photoStream.Size); var buffer = reader.ReadBuffer((uint)photoStream.Size); writer.WriteBuffer(buffer); await writer.StoreAsync(); await writer.FlushAsync(); } var status = await CachedFileManager.CompleteUpdatesAsync(file); if (status == Windows.Storage.Provider.FileUpdateStatus.Complete) { return file; } else { return null; } }
private async Task CalculateHash( IDispatcher d, HashProgress notifier) { if (notifier != null) { Action action = () => notifier(Path, 0); if (d == null) { action(); } else { d.Execute(action); } } //TODO - exception handling StorageFile file = await GetFromRoot(m_path, m_root); int num_chunks = (int) (GetSize()/Chunker.chunk_size) + 1; int hash_size = num_chunks*32; float current_chunk = 0; var hash_builder = new StringBuilder(hash_size); m_hash = ""; var chunker = new Chunker(GetSize()); foreach (Chunk chunk in chunker.GetChunks()) { using (IRandomAccessStream inputStream = await file.OpenAsync(FileAccessMode.Read)) { using (var dataReader = new DataReader(inputStream.GetInputStreamAt(chunk.Start))) { await dataReader.LoadAsync(chunk.Length); IBuffer buf = dataReader.ReadBuffer(chunk.Length); IBuffer hashed = m_alg.HashData(buf); hash_builder.Append(CryptographicBuffer.EncodeToHexString(hashed)); } } current_chunk++; if (notifier != null) { float percent_done = current_chunk/num_chunks; Action action = () => notifier(Path, percent_done*100); if (d == null) { action(); } else { d.Execute(action); } } } m_hash = hash_builder.ToString(); if (hash_size > 32) //hash the hash { // Convert the string to UTF8 binary data. IBuffer hashbuf = CryptographicBuffer.ConvertStringToBinary(m_hash, BinaryStringEncoding.Utf8); IBuffer hashed = m_alg.HashData(hashbuf); m_hash = CryptographicBuffer.EncodeToHexString(hashed); } if (notifier != null) { Action action = () => notifier(Path, 100); if (d == null) { action(); } else { d.Execute(action); } } }
public async Task UsingDataWriter() { var inMem = new InMemoryRandomAccessStream(); var datawriter = new DataWriter(inMem); var starterBytes = CryptographicBuffer.GenerateRandom(32).AsBytes(); var mStream = CryptographicBuffer.GenerateRandom(1024 * 1024).AsBytes(); MemoryStream outStream = new System.IO.MemoryStream(); var tinyStream = ConfigureStream(outStream, PwCompressionAlgorithm.GZip, true); await tinyStream.WriteAsync(starterBytes, 0, starterBytes.Length); await tinyStream.WriteAsync(mStream, 0, mStream.Length); tinyStream.Dispose(); byte[] bb = outStream.ToArray(); var source = bb.AsBuffer(); var aesKey = CryptographicBuffer.GenerateRandom(32); var iv = CryptographicBuffer.GenerateRandom(16); var encrypted = EncryptDatabase(source, aesKey, iv); CollectionAssert.AreNotEqual(mStream, encrypted.AsBytes()); datawriter.WriteBuffer(encrypted); await datawriter.StoreAsync(); datawriter.DetachStream(); datawriter.Dispose(); var i = inMem.GetInputStreamAt(0); var datareader = new DataReader(i); datareader.ByteOrder = ByteOrder.LittleEndian; await datareader.LoadAsync((uint)inMem.Size); var fromStrea = datareader.ReadBuffer(datareader.UnconsumedBufferLength); var decryped = DecryptDatabase(fromStrea, aesKey, iv); Stream bigStream = ConfigureStream(new MemoryStream(decryped.AsBytes()), PwCompressionAlgorithm.GZip, false); System.IO.MemoryStream bigStreamOut = new System.IO.MemoryStream(); bigStream.CopyTo(bigStreamOut); var buffer1 = CryptographicBuffer.CreateFromByteArray(bigStreamOut.ToArray()); var reader = DataReader.FromBuffer(buffer1); var x = reader.ReadBuffer(32).AsBytes(); CollectionAssert.AreEqual(starterBytes, x); }
private async void ProtectStreamAsync_Click(object sender, RoutedEventArgs e) { string outputStr = ""; Byte[] byteStream = { 1, 2, 3, 4, 5 }; InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream(); IOutputStream outputStream = randomAccessStream.GetOutputStreamAt(0); var writer = new DataWriter(outputStream); writer.WriteBytes(byteStream); await writer.StoreAsync(); IInputStream source = randomAccessStream.GetInputStreamAt(0); m_protectedStream = new InMemoryRandomAccessStream(); IOutputStream destination = m_protectedStream.GetOutputStreamAt(0); await DataProtectionManager.ProtectStreamAsync(source, Scenario1.m_enterpriseId, destination); var reader = new DataReader(m_protectedStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)m_protectedStream.Size); IBuffer protectedStreamBuffer = reader.ReadBuffer((uint)m_protectedStream.Size); outputStr += "\n Protected Stream buffer:" + CryptographicBuffer.EncodeToHexString(protectedStreamBuffer); rootPage.NotifyUser(outputStr, NotifyType.StatusMessage); }
public async Task<IStorageFile> ReadFileAsync(StreamSocket socket, StorageFolder folder, string outputFilename = null) { StorageFile file; using (var rw = new DataReader(socket.InputStream)) { // 1. Read the filename length await rw.LoadAsync(sizeof(Int32)); var filenameLength = (uint)rw.ReadInt32(); // 2. Read the filename await rw.LoadAsync(filenameLength); var originalFilename = rw.ReadString(filenameLength); if (outputFilename == null) { outputFilename = originalFilename; } //3. Read the file length await rw.LoadAsync(sizeof(UInt64)); var fileLength = rw.ReadUInt64(); // 4. Reading file var buffer = rw.ReadBuffer((uint)fileLength); file = await ApplicationData.Current.LocalFolder.CreateFileAsync(outputFilename, CreationCollisionOption.ReplaceExisting); await FileIO.WriteBufferAsync(file, buffer); //using (var memStream = await DownloadFile(rw, fileLength)) //{ // file = await folder.CreateFileAsync(outputFilename, CreationCollisionOption.ReplaceExisting); // using (var fileStream1 = await file.OpenAsync(FileAccessMode.ReadWrite)) // { // await RandomAccessStream.CopyAndCloseAsync(memStream.GetInputStreamAt(0), fileStream1.GetOutputStreamAt(0)); // } // rw.DetachStream(); //} } return file; }
private static async Task<StorageFile> SavePhotoAsync(FilteredPhotoModel photo, StorageFile file) { CachedFileManager.DeferUpdates(file); using (var fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)) using (var photoStream = await photo.GetFilteredPhotoAsync()) using (var reader = new DataReader(photoStream)) using (var writer = new DataWriter(fileStream)) { await reader.LoadAsync((uint)photoStream.Size); var buffer = reader.ReadBuffer((uint)photoStream.Size); writer.WriteBuffer(buffer); await writer.StoreAsync(); await writer.FlushAsync(); } var status = await CachedFileManager.CompleteUpdatesAsync(file); if (status == Windows.Storage.Provider.FileUpdateStatus.Complete) { return file; } else { return null; } }
public async void mediaalbumart() { try { StorageFile media = await Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList.GetFileAsync(futurelocation); string filename = "thumbnail" + ".png"; //var ThumbUri = new Uri("ms-appdata:///local/" + filename); // Store the file thumbnail in local applicatin storage using ( StorageItemThumbnail storageItemThumbnail = await media.GetThumbnailAsync(ThumbnailMode.SingleItem, 200, ThumbnailOptions.ResizeThumbnail)) using (IInputStream inputStreamAt = storageItemThumbnail.GetInputStreamAt(0)) using (var dataReader = new DataReader(inputStreamAt)) { uint u = await dataReader.LoadAsync((uint)storageItemThumbnail.Size); IBuffer readBuffer = dataReader.ReadBuffer(u); var tempFolder = ApplicationData.Current.LocalFolder; var imageFile = await tempFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); using (IRandomAccessStream randomAccessStream = await imageFile.OpenAsync(FileAccessMode.ReadWrite)) using (IOutputStream outputStreamAt = randomAccessStream.GetOutputStreamAt(0)) { await outputStreamAt.WriteAsync(readBuffer); await outputStreamAt.FlushAsync(); } } MediaControl.AlbumArt = new Uri("ms-appdata:///local/" + filename); } catch { // ErrorCorrecting("015"); } }
public async void albumart(StorageFile fil) { using (StorageItemThumbnail storageItemThumbnail = await fil.GetThumbnailAsync(ThumbnailMode.SingleItem, 200, ThumbnailOptions.ResizeThumbnail)) using (IInputStream inputStreamAt = storageItemThumbnail.GetInputStreamAt(0)) using (var dataReader = new DataReader(inputStreamAt)) { uint u = await dataReader.LoadAsync((uint)storageItemThumbnail.Size); IBuffer readBuffer = dataReader.ReadBuffer(u); var tempFolder = ApplicationData.Current.RoamingFolder; try { var imageFile = await tempFolder.CreateFileAsync(fil.DisplayName + ".png", CreationCollisionOption.OpenIfExists); using (IRandomAccessStream randomAccessStream = await imageFile.OpenAsync(FileAccessMode.ReadWrite)) using (IOutputStream outputStreamAt = randomAccessStream.GetOutputStreamAt(0)) { await outputStreamAt.WriteAsync(readBuffer); await outputStreamAt.FlushAsync(); } } catch { // ErrorCorrecting("013"); } } }
public async Task<IBuffer> Encrypt(string descriptor, string strMsg, BinaryStringEncoding encoding) { // Create a DataProtectionProvider object for the specified descriptor. DataProtectionProvider Provider = new DataProtectionProvider(descriptor); // Convert the input string to a buffer. IBuffer buffMsg = CryptographicBuffer.ConvertStringToBinary(strMsg, encoding); // Create a random access stream to contain the plaintext message. InMemoryRandomAccessStream inputData = new InMemoryRandomAccessStream(); // Create a random access stream to contain the encrypted message. InMemoryRandomAccessStream protectedData = new InMemoryRandomAccessStream(); // Retrieve an IOutputStream object and fill it with the input (plaintext) data. IOutputStream outputStream = inputData.GetOutputStreamAt(0); DataWriter writer = new DataWriter(outputStream); writer.WriteBuffer(buffMsg); await writer.StoreAsync(); await outputStream.FlushAsync(); // Retrieve an IInputStream object from which you can read the input data. IInputStream source = inputData.GetInputStreamAt(0); // Retrieve an IOutputStream object and fill it with encrypted data. IOutputStream dest = protectedData.GetOutputStreamAt(0); await Provider.ProtectStreamAsync(source, dest); await dest.FlushAsync(); //Verify that the protected data does not match the original DataReader reader1 = new DataReader(inputData.GetInputStreamAt(0)); DataReader reader2 = new DataReader(protectedData.GetInputStreamAt(0)); await reader1.LoadAsync((uint)inputData.Size); await reader2.LoadAsync((uint)protectedData.Size); IBuffer buffOriginalData = reader1.ReadBuffer((uint)inputData.Size); IBuffer buffProtectedData = reader2.ReadBuffer((uint)protectedData.Size); if (CryptographicBuffer.Compare(buffOriginalData, buffProtectedData)) { throw new Exception("ProtectStreamAsync returned unprotected data"); } // Return the encrypted data. return buffProtectedData; }
public async void SampleDataProtectionStream(String descriptor) { EncryptDecryptText.Text += "*** Sample Stream Data Protection for " + descriptor + " ***\n"; IBuffer data = CryptographicBuffer.GenerateRandom(10000); DataReader reader1, reader2; IBuffer buff1, buff2; DataProtectionProvider Provider = new DataProtectionProvider(descriptor); InMemoryRandomAccessStream originalData = new InMemoryRandomAccessStream(); //Populate the new memory stream IOutputStream outputStream = originalData.GetOutputStreamAt(0); DataWriter writer = new DataWriter(outputStream); writer.WriteBuffer(data); await writer.StoreAsync(); await outputStream.FlushAsync(); //open new memory stream for read IInputStream source = originalData.GetInputStreamAt(0); //Open the output memory stream InMemoryRandomAccessStream protectedData = new InMemoryRandomAccessStream(); IOutputStream dest = protectedData.GetOutputStreamAt(0); // Protect await Provider.ProtectStreamAsync(source, dest); //Flush the output if (await dest.FlushAsync()) EncryptDecryptText.Text += " Protected output was successfully flushed\n"; //Verify the protected data does not match the original reader1 = new DataReader(originalData.GetInputStreamAt(0)); reader2 = new DataReader(protectedData.GetInputStreamAt(0)); await reader1.LoadAsync((uint)originalData.Size); await reader2.LoadAsync((uint)protectedData.Size); EncryptDecryptText.Text += " Size of original stream: " + originalData.Size + "\n"; EncryptDecryptText.Text += " Size of protected stream: " + protectedData.Size + "\n"; if (originalData.Size == protectedData.Size) { buff1 = reader1.ReadBuffer((uint)originalData.Size); buff2 = reader2.ReadBuffer((uint)protectedData.Size); if (CryptographicBuffer.Compare(buff1, buff2)) { EncryptDecryptText.Text += "ProtectStreamAsync returned unprotected data"; return; } } EncryptDecryptText.Text += " Stream Compare completed. Streams did not match.\n"; source = protectedData.GetInputStreamAt(0); InMemoryRandomAccessStream unprotectedData = new InMemoryRandomAccessStream(); dest = unprotectedData.GetOutputStreamAt(0); // Unprotect DataProtectionProvider Provider2 = new DataProtectionProvider(); await Provider2.UnprotectStreamAsync(source, dest); if (await dest.FlushAsync()) EncryptDecryptText.Text += " Unprotected output was successfully flushed\n"; //Verify the unprotected data does match the original reader1 = new DataReader(originalData.GetInputStreamAt(0)); reader2 = new DataReader(unprotectedData.GetInputStreamAt(0)); await reader1.LoadAsync((uint)originalData.Size); await reader2.LoadAsync((uint)unprotectedData.Size); EncryptDecryptText.Text += " Size of original stream: " + originalData.Size + "\n"; EncryptDecryptText.Text += " Size of unprotected stream: " + unprotectedData.Size + "\n"; buff1 = reader1.ReadBuffer((uint)originalData.Size); buff2 = reader2.ReadBuffer((uint)unprotectedData.Size); if (!CryptographicBuffer.Compare(buff1, buff2)) { EncryptDecryptText.Text += "UnrotectStreamAsync did not return expected data"; return; } EncryptDecryptText.Text += "*** Done!\n"; }
private async void SavePackage() { rootPage.NotifyUser("", NotifyType.StatusMessage); FileSavePicker savePicker = new FileSavePicker(); savePicker.DefaultFileExtension = ".3mf"; savePicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary; savePicker.FileTypeChoices.Add("3MF File", new[] { ".3mf" }); var storageFile = await savePicker.PickSaveFileAsync(); if (storageFile == null) { return; } using (var stream = await currentPackage.SaveAsync()) { stream.Seek(0); using (var dataReader = new DataReader(stream)) { await dataReader.LoadAsync((uint)stream.Size); var buffer = dataReader.ReadBuffer((uint)stream.Size); await FileIO.WriteBufferAsync(storageFile, buffer); } } rootPage.NotifyUser("Saved", NotifyType.StatusMessage); }
private async static Task<bool> SaveStreamTo3MF(Windows.Storage.Streams.IRandomAccessStream stream) { // set back stream.Seek(0); using (var dataReader = new Windows.Storage.Streams.DataReader(stream)) { var dataLoad = await dataReader.LoadAsync((uint)stream.Size); if (dataLoad > 0) { var buffer = dataReader.ReadBuffer((uint)stream.Size); StorageFolder localFolder = ApplicationData.Current.LocalFolder; var outputfile = await localFolder.CreateFileAsync("output.3mf", CreationCollisionOption.ReplaceExisting); await Windows.Storage.FileIO.WriteBufferAsync(outputfile, buffer); var options = new Windows.System.LauncherOptions(); options.TargetApplicationPackageFamilyName = "Microsoft.3DBuilder_8wekyb3d8bbwe"; } } return true; }
private async void OnConnection( StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { DataReader reader = new DataReader(args.Socket.InputStream); try { while (true) { // Read first 4 bytes (length of the subsequent string). uint sizeFieldCount = await reader.LoadAsync(sizeof(uint)); if (sizeFieldCount != sizeof(uint)) { // The underlying socket was closed before we were able to read the whole data. return; } uint sizeFieldCount1 = await reader.LoadAsync(sizeof(uint)); if (sizeFieldCount1 != sizeof(uint)) { // The underlying socket was closed before we were able to read the whole data. return; } // Read the string. uint stringLength = reader.ReadUInt32(); uint msgtype = reader.ReadUInt32(); uint actualStringLength = await reader.LoadAsync(stringLength); if (stringLength != actualStringLength) { // The underlying socket was closed before we were able to read the whole data. return; } // Display the string on the screen. The event is invoked on a non-UI thread, so we need to marshal // the text back to the UI thread. if (msgtype == 1) { readByte = new byte[actualStringLength]; reader.ReadBytes(readByte); receive_byte_flag = 1; } else if (msgtype == 2) { stringtemp = reader.ReadString(actualStringLength); receive_client_ip = 1; } else if (msgtype == 3) { receiverbuf = reader.ReadBuffer(actualStringLength); receive_buf_flag = 1; } } } catch (Exception exception) { // If this is an unknown status it means that the error is fatal and retry will likely fail. if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { throw; } } }
public void Recieve(IAsyncAction operation) { while (realm.listenSocket) { Task.Delay(1); //if (clientSocket.Available > 0) { DataReader reader = new DataReader(clientSocket.InputStream); var size = reader.UnconsumedBufferLength; DataBuffer = new byte[size]; var buff = reader.ReadBuffer(size); CryptographicBuffer.CopyToByteArray(buff, out DataBuffer); HandleRealmData(DataBuffer); } } clientSocket.Dispose(); }
public static async Task<string> Recive(StreamSocket streamSocket, List<string> orstarts, List<string> orends, List<string> andstarts, List<string> andends) { string returnString = string.Empty; try { using (var dataReader = new DataReader(streamSocket.InputStream)) { dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; dataReader.InputStreamOptions = InputStreamOptions.Partial; var end = false; while (!end && await dataReader.LoadAsync(64000) != 0) { string readString; var buffer = dataReader.ReadBuffer(dataReader.UnconsumedBufferLength); using (var dr = DataReader.FromBuffer(buffer)) { var bytes1251 = new Byte[buffer.Length]; dr.ReadBytes(bytes1251); readString = Encoding.GetEncoding("UTF-8").GetString(bytes1251, 0, bytes1251.Length); } if (!string.IsNullOrEmpty(readString)) returnString += readString; if (readString == null) { end = true; } else if (orstarts.FirstOrDefault(o => returnString.StartsWith(o)) != null) { end = true; } else if (orends.FirstOrDefault(o => returnString.EndsWith(o)) != null) { end = true; } else if (andstarts.FirstOrDefault(o => returnString.StartsWith(o)) != null && andends.FirstOrDefault(o => returnString.EndsWith(o)) != null) { end = true; } } dataReader.DetachStream(); } } catch(Exception ex) { Debug.WriteLine(ex.Message); returnString = string.Empty; } return returnString; }
/// <summary> /// Reads the specified hashed block stream into a memory stream. /// </summary> /// <param name="input">The hashed block stream.</param> /// <returns>The de-hashed stream.</returns> public static async Task<Stream> Read(IInputStream input) { if (input == null) throw new ArgumentNullException("input"); var blockIndex = 0; var result = new MemoryStream(); var hash = WindowsRuntimeBuffer.Create(32); var reader = new DataReader(input) { ByteOrder = ByteOrder.LittleEndian, }; var sha = HashAlgorithmProvider .OpenAlgorithm(HashAlgorithmNames.Sha256); try { while (true) { // Detect end of file var read = await reader.LoadAsync(4); if (read == 0) break; // Verify block index var index = reader.ReadInt32(); if (index != blockIndex) { throw new InvalidDataException(string.Format( "Wrong block ID detected, expected: {0}, actual: {1}", blockIndex, index)); } blockIndex++; // Block hash hash = await input.ReadAsync(hash, 32); if (hash.Length != 32) { throw new InvalidDataException( "Data corruption detected (truncated data)"); } read = await reader.LoadAsync(4); if (read != 4) { throw new InvalidDataException( "Data corruption detected (truncated data)"); } // Validate block size (< 10MB) var blockSize = reader.ReadInt32(); if (blockSize == 0) { // Terminator block var isTerminator = hash .ToArray() .All(x => x == 0); if (!isTerminator) { throw new InvalidDataException( "Data corruption detected (invalid hash for terminator block)"); } break; } if (0 > blockSize || blockSize > 10485760) { throw new InvalidDataException( "Data corruption detected (truncated data)"); } // Check data truncate var loaded = await reader.LoadAsync((uint)blockSize); if (loaded < blockSize) { throw new InvalidDataException( "Data corruption detected (truncated data)"); } var buffer = reader.ReadBuffer((uint)blockSize); // Verify block integrity var actual = sha.HashData(buffer); if (!CryptographicBuffer.Compare(hash, actual)) { throw new InvalidDataException( "Data corruption detected (content corrupted)"); } await result.WriteAsync(buffer.ToArray(), 0, (int)buffer.Length); } result.Position = 0; return result; } catch { result.Dispose(); throw; } }
private static async Task<string> GetReceiptAsync(string productId) { var encryptedFilename = CipherEncryption(productId); var encodedFileName = Convert.ToBase64String(encryptedFilename.ToArray()); var encodedAndEscapedFilename = encodedFileName.Replace('/', '-'); //var folder = ApplicationData.Current.RoamingFolder; var folder = ApplicationData.Current.RoamingFolder; if (folder == null) return "NoReceipt"; folder = await folder.CreateFolderAsync("Receipts", CreationCollisionOption.OpenIfExists); try { var file = await folder.GetFileAsync(encodedAndEscapedFilename + ".pmd"); var stream = await file.OpenAsync(FileAccessMode.Read); var dataReader = new DataReader(stream.GetInputStreamAt(0)); uint u = await dataReader.LoadAsync((uint)stream.Size); IBuffer buffEncrypted = dataReader.ReadBuffer(u); dataReader.DetachStream(); stream.Dispose(); stream = null; var receipt = CipherDecryption(buffEncrypted); if (productId.Contains("subscritpion") && DownloadManager.ReceiptExpired(receipt)) { await file.DeleteAsync(StorageDeleteOption.PermanentDelete); return "NoReceipt"; } return receipt; } catch (Exception) { return "NoReceipt"; } }
private async Task GetUrlsFromPDF(IRandomAccessStream stream) { using (var dataReader = new DataReader(stream.GetInputStreamAt(0))) { uint u = await dataReader.LoadAsync((uint)stream.Size); IBuffer buffer = dataReader.ReadBuffer(u); GetPDFLinks(buffer); TimeSpan t = new TimeSpan(0, 0, 1); await Task.Delay(t); } }
private async Task<InMemoryRandomAccessStream> DownloadFile(DataReader rw, ulong fileLength) { var memStream = new InMemoryRandomAccessStream(); // Download the file while (memStream.Position < fileLength) { Debug.WriteLine(string.Format("Receiving file...{0}/{1} bytes", memStream.Position, fileLength)); var lenToRead = Math.Min(Constants.BLOCK_SIZE, fileLength - memStream.Position); await rw.LoadAsync((uint)lenToRead); var tempBuff = rw.ReadBuffer((uint)lenToRead); await memStream.WriteAsync(tempBuff); } //var tempBuff = rw.ReadBuffer((uint)fileLength); //await memStream.WriteAsync(tempBuff); return memStream; }
private async Task<IRandomAccessStream> GetThumbnailStreamAsync() { #if DEBUG System.Diagnostics.Debug.WriteLine("GetThumbnailStreamAsync invoked " + this.GetHashCode()); #endif var maximumSide = (int)Windows.UI.Xaml.Application.Current.Resources["ThumbnailSide"]; var orientation = await GetPhotoOrientationAsync(); var orientationValue = orientation.HasValue ? orientation.Value : PhotoOrientation.Unspecified; #if WINDOWS_PHONE_APP // TODO Getting platform thumbnails is currently broken in the WP8.1 preview SDK, // thus generating thumbnails from the large original photos. Change to platform // thumbnails again when platform is live & fine. var size = await GetPhotoResolutionAsync(); using (var stream = await GetPhotoAsync()) { return await ResizeStreamAsync(stream, new Size(maximumSide, maximumSide), orientationValue); } #else using (var stream = await _file.GetThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.PicturesView)) { if (stream.ContentType == "image/jpeg") { if (stream.OriginalWidth <= maximumSide || stream.OriginalHeight <= maximumSide) { using (var memoryStream = new InMemoryRandomAccessStream()) { using (var reader = new DataReader(stream)) using (var writer = new DataWriter(memoryStream)) { await reader.LoadAsync((uint)stream.Size); var buffer = reader.ReadBuffer((uint)stream.Size); writer.WriteBuffer(buffer); await writer.StoreAsync(); await writer.FlushAsync(); return memoryStream.CloneStream(); } } } else { return await ResizeStreamAsync(stream, new Size(maximumSide, maximumSide), orientationValue); } } else { using (var preview = await GetPreviewAsync()) { return await ResizeStreamAsync(preview, new Size(maximumSide, maximumSide), orientationValue); } } } #endif }
private void EncryptAllBookDataInDirectory(string extractToDir, CancellationToken token) { Task.WaitAll(Task.Run(async () => { try { var folder = await StorageFolder.GetFolderFromPathAsync(extractToDir); var files = await folder.GetFilesAsync(); foreach (var storageFile in files) { IBuffer encodedBuffer = null; using (var originalFileStream = await storageFile.OpenReadAsync()) { var dataReader = new DataReader(originalFileStream); var streamSize = (uint)originalFileStream.Size; await dataReader.LoadAsync(streamSize); var buffer = dataReader.ReadBuffer(streamSize); encodedBuffer = EncryptionProvider.Encrypt(buffer); } if (encodedBuffer != null) { var fileName = storageFile.Name; var encryptedFile = await folder.CreateFileAsync($"tmp_{fileName}"); using (var encryptedFileStream = await encryptedFile.OpenStreamForWriteAsync()) { var dataToWrite = encodedBuffer.ToArray(); await encryptedFileStream.WriteAsync(dataToWrite, 0, dataToWrite.Length, token); } await storageFile.DeleteAsync(StorageDeleteOption.PermanentDelete); await encryptedFile.RenameAsync(fileName, NameCollisionOption.ReplaceExisting); Debug.WriteLine($"{fileName} ENCRYPTED"); } } } catch (Exception ex) { Debug.WriteLine(ex.Message); } }, token)); }
public override async void send_file(String devicename, String bluid, int not) { try { _stopwatch.Start(); PeerFinder.AllowBluetooth = true; PeerFinder.AlternateIdentities["Bluetooth:SDP"] = "{" + bluid + "}"; var peers = await PeerFinder.FindAllPeersAsync(); foreach (var p in peers) { if (p.DisplayName.Equals(devicename)) { _peer_info = p; break; } } _bluetooth_client = new StreamSocket(); if (_peer_info.ServiceName.Equals("")) { await _bluetooth_client.ConnectAsync(_peer_info.HostName, "{" + bluid + "}"); } else { await _bluetooth_client.ConnectAsync(_peer_info.HostName, _peer_info.ServiceName); } StorageFolder folder = KnownFolders.PicturesLibrary; StorageFile file = await folder.GetFileAsync(this.filepath); IRandomAccessStreamWithContentType filestream = await file.OpenReadAsync(); _length = (uint)filestream.Size; _ibuffer = new Windows.Storage.Streams.Buffer(_length); _datareader = new DataReader(filestream); await _datareader.LoadAsync(_length); _ibuffer = _datareader.ReadBuffer(_length); _datawriter = new DataWriter(_bluetooth_client.OutputStream); _datawriter.WriteBuffer(_ibuffer); await _datawriter.StoreAsync(); filestream.Dispose(); _datareader.Dispose(); _datawriter.Dispose(); _datareader = new DataReader(_bluetooth_client.InputStream); _datareader.InputStreamOptions = InputStreamOptions.Partial; scan_received_acks(); while (true) { uint count = await _datareader.LoadAsync(4); byte[] ack = new byte[count]; _datareader.ReadBytes(ack); _counter_all_acks += BitConverter.ToInt32(ack, 0); if ((uint)_counter_all_acks == _length) break; } _datareader.Dispose(); _bluetooth_client.Dispose(); _message = format_message(_stopwatch.Elapsed, "File Transfer", "OK", this.filepath); this.callback.on_file_received(_message, this.results); this.main_view.text_to_logs(_message.Replace("\t", " ")); _ack_timer.Cancel(); _stopwatch.Stop(); } catch (Exception e) { append_error_tolog(e, _stopwatch.Elapsed, devicename); } }