| public UnprotectStreamAsync ( [ src, [ dest ) : IAsyncAction | ||
| src | [ | |
| dest | [ | |
| Результат | IAsyncAction | |
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 RestoreAsync()
{
var file = await ApplicationData.Current.LocalFolder.GetFileAsync(SessionStateFileName);
using (var inStream = await file.OpenSequentialReadAsync())
{
using (var memoryStream = new MemoryStream())
{
var provider = new DataProtectionProvider("LOCAL=user");
await provider.UnprotectStreamAsync(inStream, memoryStream.AsOutputStream());
memoryStream.Seek(0, SeekOrigin.Begin);
var bytes = memoryStream.ToArray();
this.DeserializeState(bytes);
}
}
this.LoadApplicationState();
}
public async Task RestoreSessionStateAsync()
{
_sessionState = new Dictionary<string, Dictionary<String, Object>>();
try
{
// Get the input stream for the SessionState file
StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(Constants.SessionStateFileName);
using (IInputStream inStream = await file.OpenSequentialReadAsync())
{
var memoryStream = new MemoryStream();
var provider = new DataProtectionProvider("LOCAL=user");
// Decrypt the prevously saved session data.
await provider.UnprotectStreamAsync(inStream, memoryStream.AsOutputStream());
memoryStream.Seek(0, SeekOrigin.Begin);
// Deserialize the Session State
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, Dictionary<string, object>>),
_knownTypes);
_sessionState = (Dictionary<string, Dictionary<string, object>>)serializer.ReadObject(memoryStream);
}
}
catch (Exception e)
{
throw new SessionStateServiceException(e);
}
}
public static async Task<IRandomAccessStream> UnprotectPDFStream(IRandomAccessStream source)
{
// Create a DataProtectionProvider object.
DataProtectionProvider Provider = new DataProtectionProvider();
InMemoryRandomAccessStream unprotectedData = new InMemoryRandomAccessStream();
IOutputStream dest = unprotectedData.GetOutputStreamAt(0);
await Provider.UnprotectStreamAsync(source.GetInputStreamAt(0), dest);
await unprotectedData.FlushAsync();
unprotectedData.Seek(0);
return unprotectedData;
}
/// <summary>
/// Decrypt an input stream and output to another stream
/// </summary>
/// <param name="readStream"></param>
/// <param name="outStream"></param>
/// <returns></returns>
public static async Task DecryptStream(IInputStream readStream, IOutputStream outStream, string userDescriptor)
{
// Create a DataProtectionProvider object for the specified descriptor.
DataProtectionProvider Provider = new DataProtectionProvider(userDescriptor);
await Provider.UnprotectStreamAsync(readStream, outStream); // decrypt and output
return;
}
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";
}
