protected async Task <byte[]> ConvertImageBufferToJpegBytes(IBuffer imageBuffer)
{
using (var stream = imageBuffer.AsStream().AsRandomAccessStream())
{
var decoder = await BitmapDecoder.CreateAsync(stream);
var pixels = await decoder.GetPixelDataAsync();
using (var output = new InMemoryRandomAccessStream())
{
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, output);
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore,
decoder.OrientedPixelWidth, decoder.OrientedPixelHeight, decoder.DpiX, decoder.DpiY, pixels.DetachPixelData());
});
await encoder.FlushAsync();
var buffer = WindowsRuntimeBuffer.Create((int)output.Size);
output.Seek(0);
await output.ReadAsync(buffer, (uint)output.Size, InputStreamOptions.None);
return(buffer.ToArray());
}
}
}
private async Task <FileInfo> ScanFile(StorageFile file, bool doSha1)
{
var fn = file.Name;
var basicProps = await file.GetBasicPropertiesAsync();
string sha1str = null;
if (doSha1)
{
try {
IBuffer buffer;
using (var stream = await file.OpenAsync(FileAccessMode.Read)) {
buffer = WindowsRuntimeBuffer.Create((int)basicProps.Size); // oh no we can't read large files
await stream.ReadAsync(buffer, (uint)basicProps.Size, InputStreamOptions.None);
}
var hash = Sha1.HashData(buffer);
var hashBytes = new byte[hash.Length];
hash.CopyTo(hashBytes);
sha1str = Convert.ToBase64String(hashBytes);
}
catch (UnauthorizedAccessException) { }
}
return(new FileInfo {
Name = file.Name,
Path = file.Path,
Sha1 = sha1str,
Size = basicProps.Size,
IsLoaded = true
});
}
public async Task Decrypt_should_decrypt_content()
{
using (var input = TestFiles.Read("IO.Demo7Pass.kdbx"))
{
input.Seek(222);
var masterSeed = CryptographicBuffer.DecodeFromHexString(
"2b4656399a5bdf9fdfe9e8705a34b6f484f9b1b940c3d7cfb7ffece3b634e0ae");
var masterKey = CryptographicBuffer.DecodeFromHexString(
"87730050341ff55c46421f2f2a5f4e1e018d0443d19cacc8682f128f1874d0a4");
var encryptionIV = CryptographicBuffer.DecodeFromHexString(
"f360c29e1a603a6548cfbb28da6fff50");
using (var decrypted = await FileFormat.Decrypt(input,
masterKey, masterSeed, encryptionIV))
{
var buffer = WindowsRuntimeBuffer.Create(32);
buffer = await decrypted.ReadAsync(buffer, 32);
Assert.Equal(
"54347fe32f3edbccae1fc60f72c11dafd0a72487b315f9b174ed1073ed67a6e0",
CryptographicBuffer.EncodeToHexString(buffer));
}
}
}
private void GenerateKeyMaterial(string password, uint iterationCount, out IBuffer keyMaterial, out IBuffer iv)
{
// setup KDF parameters for the desired salt and iteration count
IBuffer saltBuffer = CryptographicBuffer.CreateFromByteArray(SALT);
KeyDerivationParameters kdfParameters = KeyDerivationParameters.BuildForPbkdf2(saltBuffer, iterationCount);
// get a KDF provider for PBKDF2, and store the source password in a Cryptographic Key
KeyDerivationAlgorithmProvider kdf = KeyDerivationAlgorithmProvider.OpenAlgorithm(_keyDerivationAlgo);
var pwBytes = Encoding.GetEncoding("ASCII").GetBytes(password);
IBuffer passwordBuffer = CryptographicBuffer.CreateFromByteArray(pwBytes);
//IBuffer passwordBuffer = CryptographicBuffer.ConvertStringToBinary(password, BinaryStringEncoding.Utf8);
CryptographicKey passwordSourceKey = kdf.CreateKey(passwordBuffer);
// generate key material from the source password, salt, and iteration count. Only call DeriveKeyMaterial once,
// since calling it twice will generate the same data for the key and IV.
int keySize = 256 / 8;
int ivSize = 128 / 8;
uint totalDataNeeded = (uint)(keySize + ivSize);
IBuffer keyAndIv = CryptographicEngine.DeriveKeyMaterial(passwordSourceKey, kdfParameters, totalDataNeeded);
// split the derived bytes into a seperate key and IV
byte[] keyMaterialBytes = keyAndIv.ToArray();
keyMaterial = WindowsRuntimeBuffer.Create(keyMaterialBytes, 0, keySize, keySize);
iv = WindowsRuntimeBuffer.Create(keyMaterialBytes, keySize, ivSize, ivSize);
}
public void Create_Capacity_ReturnsExpected(int capacity)
{
IBuffer buffer = WindowsRuntimeBuffer.Create(capacity);
Assert.Equal(capacity, (int)buffer.Capacity);
Assert.Equal(0, (int)buffer.Length);
}
public static async Task <IBuffer> SaveAsPngIntoBufferAsync(this Canvas canvas, double _scaleFactor, int dpiForImage = 200)
{
//string currentresolution = Window.Current.Bounds.Width * scaleFactor + "*" + Window.Current.Bounds.Height * scaleFactor;
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
await renderTargetBitmap.RenderAsync(canvas);
var pixels = await renderTargetBitmap.GetPixelsAsync();
using (IRandomAccessStream stream = new InMemoryRandomAccessStream())
{
var encoder = await
BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
byte[] bytes = pixels.ToArray();
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
encoder.SetPixelData(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Ignore,
(uint)(canvas.ActualWidth * _scaleFactor), (uint)(canvas.ActualHeight * _scaleFactor),
dpiForImage, dpiForImage, bytes);
});
await encoder.FlushAsync();
stream.Seek(0);
var buffer = WindowsRuntimeBuffer.Create((int)stream.Size);
await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None);
return(buffer);
}
}
/// <summary>
/// Saves photo to photo library
/// </summary>
/// <param name="data">image data to save</param>
/// <param name="folder">folder name in photo libray to use</param>
/// <param name="filename">filename of image to save</param>
/// <returns>task to wait on</returns>
public async Task SavePhotoAsync(byte[] data, string folder, string filename)
{
StorageFolder picturesDirectory = KnownFolders.PicturesLibrary;
StorageFolder folderDirectory = picturesDirectory;
// Get the folder or create it if necessary
if (!string.IsNullOrEmpty(folder))
{
try
{
folderDirectory = await picturesDirectory.GetFolderAsync(folder);
}
catch (Exception)
{
folderDirectory = null;
}
if (folderDirectory == null)
{
folderDirectory = await picturesDirectory.CreateFolderAsync(folder);
}
}
// Create the file.
StorageFile storageFile = await folderDirectory.CreateFileAsync(
filename,
CreationCollisionOption.GenerateUniqueName);
// Convert byte[] to Windows buffer and write it out.
IBuffer buffer = WindowsRuntimeBuffer.Create(data, 0, data.Length, data.Length);
await FileIO.WriteBufferAsync(storageFile, buffer);
}
public async Task Should_read_correctly_formatted_stream()
{
using (var input = new InMemoryRandomAccessStream())
using (var expectedData = TestFiles.Read("IO.HashedBlockStream.Content.bin"))
{
await CopyData(input, "IO.HashedBlockStream.bin");
input.Seek(0);
expectedData.Seek(0);
using (var actualData = await HashedBlockFileFormat.Read(input))
{
Assert.Equal(expectedData.Size, (ulong)actualData.Length);
var actual = new byte[1024];
var expected = WindowsRuntimeBuffer.Create(actual.Length);
while (true)
{
expected = await expectedData.ReadAsync(expected);
var read = await actualData.ReadAsync(actual, 0, actual.Length);
Assert.Equal(expected.Length, (uint)read);
if (read == 0)
{
break;
}
Assert.Equal(expected.ToArray(), actual.Take(read));
}
}
}
}
public async Task Should_produce_read_bytes_hash(int bufferSize)
{
var data = CryptographicBuffer.GenerateRandom(2048);
var expected = HashAlgorithmProvider
.OpenAlgorithm(HashAlgorithmNames.Sha256)
.HashData(data);
using (var file = new InMemoryRandomAccessStream())
{
await file.WriteAsync(data);
file.Seek(0);
var buffer = WindowsRuntimeBuffer.Create(bufferSize);
using (var hashed = new HashedInputStream(file))
{
for (var i = 0; i < 8; i++)
{
await hashed.ReadAsync(
buffer, buffer.Capacity);
}
var hash = hashed.GetHashAndReset();
Assert.Equal(expected.ToArray(), hash.ToArray());
}
}
}
/// <summary>
/// Asynchronously transforms the user's 32-byte key using ECB AES.
///
/// Since Rijndael works on 16-byte blocks, the k is split in half and
/// each half is encrypted separately the same number of times.
/// </summary>
/// <param name="rawKey">The key to transform.</param>
/// <param name="token">Token used to cancel the transform task.</param>
/// <returns>The transformed key.</returns>
public async Task <IBuffer> TransformKeyAsync(IBuffer rawKey, CancellationToken token)
{
if (rawKey == null)
{
throw new ArgumentNullException(nameof(rawKey));
}
if (rawKey.Length != 32)
{
throw new ArgumentException("Key must be 32 bytes", nameof(rawKey));
}
// Split the k buffer in half
byte[] rawKeyBytes = rawKey.ToArray();
IBuffer lowerBuffer = WindowsRuntimeBuffer.Create(rawKeyBytes, 0, 16, 16);
IBuffer upperBuffer = WindowsRuntimeBuffer.Create(rawKeyBytes, 16, 16, 16);
// Set up the encryption parameters
var aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcb);
CryptographicKey key = aes.CreateSymmetricKey(this.algoParams.Seed);
IBuffer iv = null;
// Run the encryption rounds in two threads (upper and lower)
ConditionChecker checkForCancel = () => token.IsCancellationRequested;
Task <bool> lowerTask = Task.Run(() =>
{
lowerBuffer = KeePassHelper.TransformKey(this.algoParams.Rounds, this.algoParams.Seed, iv, lowerBuffer, checkForCancel);
return(!checkForCancel());
}
);
Task <bool> upperTask = Task.Run(() =>
{
upperBuffer = KeePassHelper.TransformKey(this.algoParams.Rounds, this.algoParams.Seed, iv, upperBuffer, checkForCancel);
return(!checkForCancel());
}
);
// Verify the work was completed successfully
await Task.WhenAll(lowerTask, upperTask);
if (!(lowerTask.Result && upperTask.Result))
{
return(null);
}
// Copy the units of work back into one buffer, hash it, and return.
IBuffer transformedKey = (new byte[32]).AsBuffer();
lowerBuffer.CopyTo(0, transformedKey, 0, 16);
upperBuffer.CopyTo(0, transformedKey, 16, 16);
var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
CryptographicHash hash = sha256.CreateHash();
hash.Append(transformedKey);
return(hash.GetValueAndReset());
}
private static string GetCaptureFileName(Uri source)
{
const string pattern = "\\\\|\\/|:|\\?|\\*|\"|<|>|\\|";
var regex = new Regex(pattern);
var evaluator = new MatchEvaluator(ConvertToLegalPath);
var bytes = Encoding.UTF8.GetBytes(source.OriginalString);
var str = Convert.ToBase64String(SHA1.HashData(WindowsRuntimeBuffer.Create(bytes, 0, bytes.Length, bytes.Length)).ToArray());
return(regex.Replace(str, evaluator));
}
/// <summary>
/// Reads the headers of the specified database file stream.
/// </summary>
/// <param name="input">The input stream.</param>
/// <returns>The read result.</returns>
/// <exception cref="ArgumentNullException">
/// The <paramref name="input"/> cannot be <c>null</c>.
/// </exception>
public static async Task <ReadHeaderResult> Headers(IInputStream input)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
var hash = new HashedInputStream(input);
var buffer = WindowsRuntimeBuffer.Create(128);
// Signature
buffer = await hash.ReadAsync(buffer, 8);
var format = CheckSignature(buffer);
if (format != FileFormats.Supported)
{
return(new ReadHeaderResult
{
Format = format,
});
}
// Schema version
buffer = await hash.ReadAsync(buffer, 4);
var version = GetVersion(buffer);
format = CheckCompatibility(version);
switch (format)
{
case FileFormats.Supported:
case FileFormats.PartialSupported:
break;
default:
return(new ReadHeaderResult
{
Format = format,
});
}
// Fields
var headers = await GetHeaders(hash, buffer);
headers.Hash = hash.GetHashAndReset();
return(new ReadHeaderResult
{
Format = format,
Headers = headers,
});
}
/// <summary>
/// Computes how many key transformation rounds can occur in one second.
/// </summary>
/// <returns>A task representing the computed value.</returns>
public Task <ulong> ComputeOneSecondDelay()
{
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
return(Task.Run(() =>
{
IBuffer keyBuffer = WindowsRuntimeBuffer.Create(new byte[32], 0, 32, 32);
IBuffer dataBuffer = WindowsRuntimeBuffer.Create(new byte[32], 0, 32, 32);
bool checkForCancel() => cts.Token.IsCancellationRequested;
return KeePassHelper.TransformUntilCancelled(keyBuffer, dataBuffer, checkForCancel);
}));
}
protected override void SendToRemote(byte[] e)
{
if (remoteConnected)
{
try
{
r.Send(e);
}
catch (Exception)
{
Debug.WriteLine("Cannot send to remote");
Dispose();
return;
}
LogData("Sent to remote ", e);
// Send header first, followed by local buffer
if (localbuf != null)
{
IBuffer newLocalbuf;
lock (localbuf)
{
if (localbuf != null && localbuf.Length > 0)
{
newLocalbuf = WindowsRuntimeBuffer.Create((int)localbuf.Length);
localbuf.CopyTo(newLocalbuf);
newLocalbuf.Length = localbuf.Length;
//LogData("Sending local buffer ", newLocalbuf.ToArray());
localbuf = null;
}
else
{
localbuf = null;
return;
}
}
r.Send(newLocalbuf.ToArray());
Debug.WriteLine("Buffer sent");
//await r.OutputStream.WriteAsync(outData.Take((int)len).ToArray().AsBuffer());
}
return;
}
else
{
lock (localbuf)
{
e.CopyTo(0, localbuf, localbuf.Length, e.Length);
localbuf.Length += (uint)e.Length;
}
return;
}
}
public async Task <bool> SaveImageAsync(byte[] data, string filename, string folder = null)
{
if (folder == null)
{
folder = ImageEditor.Instance.FolderName;
}
StorageFolder picturesDirectory = KnownFolders.PicturesLibrary;
StorageFolder folderDirectory = picturesDirectory;
// Get the folder or create it if necessary
if (!string.IsNullOrEmpty(folder))
{
try
{
folderDirectory = await picturesDirectory.GetFolderAsync(folder);
}
catch
{ }
if (folderDirectory == null)
{
try
{
folderDirectory = await picturesDirectory.CreateFolderAsync(folder);
}
catch
{
return(false);
}
}
}
try
{
// Create the file.
StorageFile storageFile = await folderDirectory.CreateFileAsync(filename,
CreationCollisionOption.GenerateUniqueName);
// Convert byte[] to Windows buffer and write it out.
IBuffer buffer = WindowsRuntimeBuffer.Create(data, 0, data.Length, data.Length);
await FileIO.WriteBufferAsync(storageFile, buffer);
}
catch (Exception)
{
return(false);
}
return(true);
}
private static async Task CopyData(IOutputStream output, string name)
{
using (var input = TestFiles.Read(name))
{
var buffer = WindowsRuntimeBuffer.Create(1024);
do
{
buffer = await input.ReadAsync(
buffer, buffer.Capacity);
await output.WriteAsync(buffer);
} while (buffer.Length > 0);
}
}
/// <summary>
/// Given a stream past the header, asynchronously fetches encrypted ciphertext
/// from the file as a single buffer.
/// </summary>
/// <remarks>
/// For KDBX3.1, this is just the rest of the stream. For KDBX4, it involves
/// pulling out HMAC blocks from the stream.
/// </remarks>
/// <param name="dataStream">The stream representing the remainder of the database file.</param>
/// <returns>A buffer representing the encrypted database.</returns>
private async Task <IBuffer> GetCipherText(IRandomAccessStream dataStream, HmacBlockHandler macHandler)
{
uint streamRemaining = (uint)(dataStream.Size - dataStream.Position);
DebugHelper.Trace("Stream has {0} bytes remaining.", streamRemaining);
IBuffer fileRemainder;
using (DataReader reader = GetReaderForStream(dataStream))
{
if (this.parameters.UseHmacBlocks)
{
// KDBX 4: HMAC block content
int bytesLeft = (int)streamRemaining;
DebugHelper.Assert(bytesLeft > 0);
fileRemainder = WindowsRuntimeBuffer.Create(bytesLeft);
for (ulong index = 0; bytesLeft > 0; index++)
{
IBuffer block = await macHandler.ReadCipherBlockAsync(reader, index);
if (block == null || block.Length == 0)
{
break;
}
DebugHelper.Assert((int)block.Length > 0);
bytesLeft -= (int)block.Length + 4 + 32;
block.CopyTo(0, fileRemainder, fileRemainder.Length, block.Length);
fileRemainder.Length += block.Length;
}
}
else
{
// KDBX 3.1: Rest of file as-is
DebugHelper.Assert(reader.UnconsumedBufferLength == 0);
await reader.LoadAsync(streamRemaining).AsTask().ConfigureAwait(false);
fileRemainder = reader.ReadBuffer(streamRemaining);
}
reader.DetachStream();
return(fileRemainder);
}
}
public void GenerateKey(string password, string salt, out Windows.Storage.Streams.IBuffer keyMaterial, out Windows.Storage.Streams.IBuffer iv)
{
IBuffer saltBuffer = CryptographicBuffer.ConvertStringToBinary(salt, BinaryStringEncoding.Utf8);
KeyDerivationParameters keyParams = KeyDerivationParameters.BuildForSP800108(saltBuffer, GetNonce());
KeyDerivationAlgorithmProvider kdf = KeyDerivationAlgorithmProvider.OpenAlgorithm(Encryptor.Settings.KeyDerivationAlgorithm);
IBuffer passwordBuffer = CryptographicBuffer.ConvertStringToBinary(password, BinaryStringEncoding.Utf8);
CryptographicKey keyOriginal = kdf.CreateKey(passwordBuffer);
int keySize = 256;
int ivSize = 128 / 8;
uint totalData = (uint)(keySize + ivSize);
IBuffer keyDerived = CryptographicEngine.DeriveKeyMaterial(keyOriginal, keyParams, totalData);
byte[] keyMaterialBytes = keyDerived.ToArray();
keyMaterial = WindowsRuntimeBuffer.Create(keyMaterialBytes, 0, keySize, keySize);
iv = WindowsRuntimeBuffer.Create(keyMaterialBytes, keySize, ivSize, ivSize);
}
/// <summary>
/// Decrypts the specified input stream.
/// </summary>
/// <param name="input">The input stream.</param>
/// <param name="masterKey">The master key.</param>
/// <param name="masterSeed">The master seed.</param>
/// <param name="encryptionIV">The encryption initialization vector.</param>
/// <returns>The decrypted buffer.</returns>
/// <exception cref="ArgumentNullException">
/// The <paramref name="input"/>, <paramref name="masterSeed"/>, <paramref name="masterKey"/>
/// and <paramref name="encryptionIV"/> cannot be <c>null</c>.
/// </exception>
public static async Task <IInputStream> Decrypt(IRandomAccessStream input,
IBuffer masterKey, IBuffer masterSeed, IBuffer encryptionIV)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (masterSeed == null)
{
throw new ArgumentNullException("masterSeed");
}
if (masterKey == null)
{
throw new ArgumentNullException("masterKey");
}
if (encryptionIV == null)
{
throw new ArgumentNullException("encryptionIV");
}
var sha = HashAlgorithmProvider
.OpenAlgorithm(HashAlgorithmNames.Sha256)
.CreateHash();
sha.Append(masterSeed);
sha.Append(masterKey);
var seed = sha.GetValueAndReset();
var aes = SymmetricKeyAlgorithmProvider
.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7)
.CreateSymmetricKey(seed);
var buffer = WindowsRuntimeBuffer.Create(
(int)(input.Size - input.Position));
buffer = await input.ReadAsync(buffer, buffer.Capacity);
buffer = CryptographicEngine.Decrypt(aes, buffer, encryptionIV);
var stream = new InMemoryRandomAccessStream();
await stream.WriteAsync(buffer);
stream.Seek(0);
return(stream);
}
public static async Task <SteamWebApi> GetInstance()
{
if (m_instance != null)
{
return(m_instance);
}
var file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///api_steam.txt"));
var stream = await file.OpenReadAsync();
var buf = WindowsRuntimeBuffer.Create(ApiKeyLength);
buf = await stream.ReadAsync(buf, ApiKeyLength, InputStreamOptions.None);
var apiKey = Encoding.ASCII.GetString(buf.ToArray());
return(m_instance = new SteamWebApi(apiKey));
}
/// <summary>
/// Hashes and writes a null terminator block to the specified writer.
/// </summary>
/// <param name="writer">Writer used to output data.</param>
/// <param name="blockIndex">Block index used to compute HMAC key.</param>
/// <returns>A task that resolves when output is finished.</returns>
public async Task WriteTerminatorAsync(DataWriter writer, ulong blockIndex)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
IBuffer nullData = WindowsRuntimeBuffer.Create(0);
IBuffer hmacValue = GetMacForBlock(blockIndex, nullData, 0, 0);
writer.WriteBuffer(hmacValue);
await writer.StoreAsync();
writer.WriteUInt32(0);
await writer.StoreAsync();
DebugHelper.Trace($"Wrote HMAC terminator block #{blockIndex}.");
DebugHelper.Trace($"MAC[0]: {hmacValue.GetByte(0)}, MAC[31]: {hmacValue.GetByte(31)}");
}
public void Create_Buffer_ReturnsExpected(byte[] source, int offset, int length, int capacity)
{
IBuffer buffer = WindowsRuntimeBuffer.Create(source, offset, length, capacity);
Assert.Equal(capacity, (int)buffer.Capacity);
Assert.Equal(length, (int)buffer.Length);
for (uint i = 0; i < length; i++)
{
Assert.Equal(source[i + offset], buffer.GetByte(i));
}
// The source byte array should be copied.
if (source.Length > 0)
{
source[0] = 45;
Assert.NotEqual(45, buffer.GetByte(0));
}
}
internal static async Task <FeedbackAttachmentVM> LoadFromStorageAsync(string filename)
{
var helper = HockeyClient.Current.AsInternal().PlatformHelper;
var imageFileName = filename.Substring(filename.IndexOf(AttachmentNameSeparator) + 1).Replace(AttachmentFileExt, "");
var fbAttachVM = new FeedbackAttachmentVM();
using (var stream = (await helper.GetStreamAsync(filename, ConstantsUniversal.FeedbackAttachmentTmpDir)).AsRandomAccessStream())
{
var buffer = WindowsRuntimeBuffer.Create((int)stream.Size);
await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None);
fbAttachVM.ImageBuffer = buffer;
fbAttachVM.InitialImage = await buffer.AsBitmapImageAsync();
fbAttachVM.FeedbackAttachment.FileName = imageFileName;
}
return(fbAttachVM);
}
private static void GenerateKeyMaterial(IBuffer passwordBuffer, IBuffer saltBuffer, uint iterationCount, out IBuffer keyMaterial, out IBuffer iv)
{
KeyDerivationParameters kdfParameters = KeyDerivationParameters.BuildForPbkdf2(saltBuffer, iterationCount);
// Get a KDF provider for PBKDF2, and store the source password in a Cryptographic Key
KeyDerivationAlgorithmProvider kdf = KeyDerivationAlgorithmProvider.OpenAlgorithm(KeyDerivationAlgorithmNames.Pbkdf2Sha256);
CryptographicKey passwordSourceKey = kdf.CreateKey(passwordBuffer);
// Generate key material from the source password, salt, and iteration count. Only call DeriveKeyMaterial once,
// since calling it twice will generate the same data for the key and IV.
int keySize = 256 / 8;
int ivSize = 128 / 8;
uint totalDataNeeded = (uint)(keySize + ivSize);
IBuffer keyAndIv = CryptographicEngine.DeriveKeyMaterial(passwordSourceKey, kdfParameters, totalDataNeeded);
// Split the derived bytes into a seperate key and IV
byte[] keyMaterialBytes = keyAndIv.ToArray();
keyMaterial = WindowsRuntimeBuffer.Create(keyMaterialBytes, 0, keySize, keySize);
iv = WindowsRuntimeBuffer.Create(keyMaterialBytes, keySize, ivSize, ivSize);
}
public async Task <bool> SavePhotoAsync(byte[] data, string folder, string filename)
{
StorageFolder picturesDirectory = KnownFolders.PicturesLibrary;
StorageFolder folderDirectory = picturesDirectory;
// ottiene la cartella o crearla se necessario
if (!string.IsNullOrEmpty(folder))
{
try
{
folderDirectory = await picturesDirectory.GetFolderAsync(folder);
}
catch
{ }
if (folderDirectory == null)
{
try
{
folderDirectory = await picturesDirectory.CreateFolderAsync(folder);
}
catch
{
return(false);
}
}
}
try
{
// crea il file
StorageFile storageFile = await folderDirectory.CreateFileAsync(filename, CreationCollisionOption.GenerateUniqueName);
// converte byte[] in buffer di Windows e lo scrive
IBuffer buffer = WindowsRuntimeBuffer.Create(data, 0, data.Length, data.Length);
await FileIO.WriteBufferAsync(storageFile, buffer);
}
catch
{
return(false);
}
return(true);
}
public async Task <bool> SaveBitmap(byte[] bitmapData, string filename)
{
StorageFolder picturesFolder = KnownFolders.PicturesLibrary;
StorageFolder spinPaintFolder = null;
// Get the folder or create it if necessary
try
{
spinPaintFolder = await picturesFolder.GetFolderAsync("SpinPaint");
}
catch
{ }
if (spinPaintFolder == null)
{
try
{
spinPaintFolder = await picturesFolder.CreateFolderAsync("SpinPaint");
}
catch
{
return(false);
}
}
try
{
// Create the file.
StorageFile storageFile = await spinPaintFolder.CreateFileAsync(filename);
// Convert byte[] to Windows buffer and write it out.
IBuffer buffer = WindowsRuntimeBuffer.Create(bitmapData, 0, bitmapData.Length, bitmapData.Length);
await FileIO.WriteBufferAsync(storageFile, buffer);
}
catch
{
return(false);
}
return(true);
}
/// <summary>
/// Loads the specified key file.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">
/// The <paramref name="input"/> parameter cannot be <c>null</c>.
/// </exception>
private static async Task <IBuffer> LoadKeyFile(IRandomAccessStream input)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
var buffer = WindowsRuntimeBuffer.Create(1024);
switch (input.Size)
{
case 32: // Binary key file
return(await input.ReadAsync(buffer, 32));
case 64: // Hex text key file
buffer = await input.ReadAsync(buffer, 64);
var hex = CryptographicBuffer.ConvertBinaryToString(
BinaryStringEncoding.Utf8, buffer);
if (IsHexString(hex))
{
return(CryptographicBuffer.DecodeFromHexString(hex));
}
break;
}
// XML
input.Seek(0);
var xml = LoadXmlKeyFile(input);
if (xml != null)
{
return(xml);
}
// Random keyfile
input.Seek(0);
return(await GetFileHash(input, buffer));
}
public async Task <bool> SavePhotoAsync(byte[] data, string folder, string filename)
{
StorageFolder picturesDirectory = KnownFolders.PicturesLibrary;
StorageFolder folderDirectory = picturesDirectory;
// Get the folder or create it if necessary
try
{
// Create the file.
StorageFile storageFile = await folderDirectory.CreateFileAsync(filename,
CreationCollisionOption.ReplaceExisting);
// Convert byte[] to Windows buffer and write it out.
IBuffer buffer = WindowsRuntimeBuffer.Create(data, 0, data.Length, data.Length);
await FileIO.WriteBufferAsync(storageFile, buffer);
}
catch
{
return(false);
}
return(true);
}
public async Task Headers_should_detect_partial_support_format()
{
using (var database = TestFiles.Read("IO.Demo7Pass.kdbx"))
using (var file = new InMemoryRandomAccessStream())
{
var buffer = WindowsRuntimeBuffer.Create(512);
buffer = await database.ReadAsync(
buffer, 512, InputStreamOptions.None);
await file.WriteAsync(buffer);
file.Seek(8);
// Schema; 3.Max
await file.WriteAsync(CryptographicBuffer
.DecodeFromHexString("FFFF0300"));
file.Seek(0);
var result = await FileFormat.Headers(file);
Assert.NotNull(result.Headers);
Assert.Equal(FileFormats.PartialSupported, result.Format);
}
}
private void SetCommands()
{
AddAttachmentCommand = new RelayCommand(async() =>
{
var picker = new FileOpenPicker();
picker.ViewMode = PickerViewMode.List;
picker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
picker.FileTypeFilter.Add("*");
var files = await picker.PickMultipleFilesAsync();
foreach (var file in files)
{
byte[] bytes = null;
using (var stream = await file.OpenReadAsync()) {
IBuffer buffer = WindowsRuntimeBuffer.Create((int)stream.Size);
await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None);
bytes = buffer.ToArray();
}
var attach = new FeedbackAttachment(file.Name, bytes, file.ContentType);
this.Attachments.Add(new FeedbackAttachmentVM(attach)
{
FeedbackMessageVM = this
});
}
});
OpenAttachmentCommand = new RelayCommand(async(o) =>
{
await((FeedbackAttachmentVM)o).OpenAttachmentAsync();
});
SendMessageCommand = new RelayCommand(async(o) =>
{
bool success = true;
if (await ValidateInputAsync())
{
if (NetworkInterface.GetIsNetworkAvailable())
{
this.IsBusy = true;
try
{
IFeedbackMessage sentMessage = await this.SendFeedbackAsync();
this.FeedbackThreadVM.HandleSentMessage(sentMessage);
}
catch (Exception e)
{
HockeyClient.Current.AsInternal().HandleInternalUnhandledException(e);
success = false;
}
finally
{
this.IsBusy = false;
}
if (!success)
{
await new MessageDialog(LocalizedStrings.LocalizedResources.FeedbackSendError).ShowAsync();
FeedbackFlyoutVM.ShowFlyout();
}
}
else
{
await new MessageDialog(LocalizedStrings.LocalizedResources.FeedbackNoInternet).ShowAsync();
FeedbackFlyoutVM.ShowFlyout();
}
}
else
{
FeedbackFlyoutVM.ShowFlyout();
}
});
CancelMessageCommand = new RelayCommand((o) => {
this.Message = null;
this.Attachments.Clear();
});
if (!String.IsNullOrWhiteSpace(this.Email))
{
Task t = this.ReLoadGravatar();
}
else
{
this.Gravatar = GravatarHelper.DefaultGravatar;
}
}
