| public ProtectStreamAsync ( [ src, [ dest ) : IAsyncAction | ||
| src | [ | |
| dest | [ | |
| return | IAsyncAction | |
/// <summary>
/// Encrypt an input stream and output to another stream
/// </summary>
/// <param name="inStream"></param>
/// <param name="outStream"></param>
/// <param name="userDescriptor"></param>
/// <returns></returns>
public static async Task ProtectStreamToStream(IInputStream inStream, IOutputStream outStream, string userDescriptor)
{
// Create a DataProtectionProvider object for the specified descriptor.
DataProtectionProvider Provider = new DataProtectionProvider(userDescriptor);
await Provider.ProtectStreamAsync(inStream, outStream);
}
public async Task SaveAsync()
{
this.SaveApplicationState();
var file = await ApplicationData.Current.LocalFolder.CreateFileAsync(SessionStateFileName, CreationCollisionOption.ReplaceExisting);
var bytes = this.SerializeState(this.states);
using (var sessionData = new MemoryStream(bytes))
{
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
sessionData.Seek(0, SeekOrigin.Begin);
var provider = new DataProtectionProvider("LOCAL=user");
await provider.ProtectStreamAsync(sessionData.AsInputStream(), fileStream);
await fileStream.FlushAsync();
}
}
}
/// <summary>
/// Save the current <see cref="SessionState"/>. Any <see cref="Frame"/> instances
/// registered with <see cref="RegisterFrame"/> will also preserve their current
/// navigation stack, which in turn gives their active <see cref="Page"/> an opportunity
/// to save its state.
/// </summary>
/// <returns>An asynchronous task that reflects when session state has been saved.</returns>
public async Task SaveAsync()
{
try
{
// Save the navigation state for all registered frames
foreach (var weakFrameReference in _registeredFrames)
{
IFrameFacade frame;
if (weakFrameReference.TryGetTarget(out frame))
{
SaveFrameNavigationState(frame);
}
}
// Serialize the session state synchronously to avoid asynchronous access to shared
// state
MemoryStream sessionData = new MemoryStream();
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
serializer.WriteObject(sessionData, _sessionState);
// Get an output stream for the SessionState file and write the state asynchronously
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(Constants.SessionStateFileName, CreationCollisionOption.ReplaceExisting);
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
sessionData.Seek(0, SeekOrigin.Begin);
var provider = new DataProtectionProvider("LOCAL=user");
// Encrypt the session data and write it to disk.
await provider.ProtectStreamAsync(sessionData.AsInputStream(), fileStream);
await fileStream.FlushAsync();
}
}
catch (Exception e)
{
throw new SessionStateServiceException(e);
}
}
public static async Task<IRandomAccessStream> ProtectPDFStream(IRandomAccessStream source)
{
// Create a DataProtectionProvider object for the specified descriptor.
DataProtectionProvider Provider = new DataProtectionProvider("LOCAL=user");
InMemoryRandomAccessStream protectedData = new InMemoryRandomAccessStream();
IOutputStream dest = protectedData.GetOutputStreamAt(0);
await Provider.ProtectStreamAsync(source.GetInputStreamAt(0), dest);
await dest.FlushAsync();
//Verify that the protected data does not match the original
//DataReader reader1 = new DataReader(source.GetInputStreamAt(0));
//DataReader reader2 = new DataReader(protectedData.GetInputStreamAt(0));
//var size1 = await reader1.LoadAsync((uint)(source.Size < 10000 ? source.Size : 10000));
//var size2 = await reader2.LoadAsync((uint)(protectedData.Size < 10000 ? protectedData.Size : 10000));
//IBuffer buffOriginalData = reader1.ReadBuffer((uint)size1);
//IBuffer buffProtectedData = reader2.ReadBuffer((uint)size2);
//if (CryptographicBuffer.Compare(buffOriginalData, buffProtectedData))
//{
// throw new Exception("ProtectPDFStream returned unprotected data");
//}
//protectedData.Seek(0);
//await protectedData.FlushAsync();
// Return the encrypted data.
return protectedData;
}
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";
}
