public IBuffer HashData (IBuffer data)
{
if (data == null)
return new byte[HashLength].AsBuffer();
return this.context.ComputeHash (data.AsStream()).AsBuffer();
}
public static string GetHash(Windows.Storage.Streams.IBuffer buffer)
{
var algorithm = Windows.Security.Cryptography.Core.HashAlgorithmProvider.OpenAlgorithm("SHA1");
var hash = algorithm.HashData(buffer);
return(Windows.Security.Cryptography.CryptographicBuffer.EncodeToBase64String(hash));
}
/// <summary>
/// Encodes a buffer to a base64 string.
/// </summary>
/// <param name="buffer">Input buffer.</param>
/// <returns>Base64-encoded output string.</returns>
public static string EncodeToBase64String( IBuffer buffer )
{
if (buffer == null)
throw new ArgumentNullException("buffer");
return Convert.ToBase64String(buffer.ToArray());
}
public Rc4RandomGenerator(IBuffer key)
{
if (key == null)
throw new ArgumentNullException("key");
_state = new byte[256];
var keyLength = key.Length;
for (uint w = 0; w < 256; ++w)
_state[w] = (byte)w;
unchecked
{
byte j = 0;
uint keyIndex = 0;
for (uint w = 0; w < 256; ++w) // Key setup
{
j += (byte)(_state[w] + key.GetByte(keyIndex));
var temp = _state[0];
_state[0] = _state[j];
_state[j] = temp;
++keyIndex;
if (keyIndex >= keyLength)
keyIndex = 0;
}
}
GetRandomBytes(512);
}
public static IBuffer Encrypt(IBuffer data,
CryptographicKey key,
out IBuffer iv,
String AlgorithmName = null)
{
//declares
var strAlgName = AlgorithmName != null ? AlgorithmName : DefaultAlgorithm;
iv = null;
// Open a symmetric algorithm provider for the specified algorithm.
var objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(strAlgName);
// Determine whether the message length is a multiple of the block length.
// This is not necessary for PKCS #7 algorithms which automatically pad the
// message to an appropriate length.
if (!strAlgName.Contains("PKCS7"))
{
if ((data.Length % objAlg.BlockLength) != 0)
throw new Exception("Message buffer length must be multiple of block length.");
}
// CBC algorithms require an initialization vector. Here, a random
// number is used for the vector.
if (strAlgName.Contains("CBC"))
iv = CryptographicBuffer.GenerateRandom(objAlg.BlockLength);
// Encrypt the data and return.
return CryptographicEngine.Encrypt(key, data, iv);
}
// Sample the original image
private void SampleOriginalImage()
{
originalBitmap = new WriteableBitmap(originalImage);
double ratio = (double)originalBitmap.PixelWidth / (double)originalBitmap.PixelHeight;
double w = Application.Current.RootVisual.RenderSize.Width;
double h = Application.Current.RootVisual.RenderSize.Height;
double previewWidth;
double previewHeight;
if (w / ratio > h)
{
previewHeight = h;
previewWidth = h * ratio;
}
else
{
previewWidth = w;
previewHeight = w / ratio;
}
originalPreviewBitmap = originalBitmap.Resize((int)previewWidth, (int)previewHeight, System.Windows.Media.Imaging.WriteableBitmapExtensions.Interpolation.Bilinear);
currentPreviewBitmap = originalBitmap.Resize((int)previewWidth, (int)previewHeight, System.Windows.Media.Imaging.WriteableBitmapExtensions.Interpolation.Bilinear);
// Create buffer
previewStream = new MemoryStream();
currentPreviewBitmap.SaveJpeg(previewStream, originalPreviewBitmap.PixelWidth, originalPreviewBitmap.PixelHeight, 0, 75);
previewBuffer = previewStream.GetWindowsRuntimeBuffer();
}
public void SaveToPicturesLibrary(IBuffer imageBuffer, [CallerMemberName] string fileName = "", [CallerFilePath]string callerFilePath = "")
{
fileName = Path.GetFileNameWithoutExtension(callerFilePath) + "_" + fileName;
if (!Path.HasExtension(fileName))
{
fileName = Path.ChangeExtension(fileName, "jpg");
}
lock (m_lockObject)
{
if (m_isClosed)
{
throw new InvalidOperationException("ImageResults closed, cannot queue more operations.");
}
m_saveTask = m_saveTask.ContinueWith(async _ =>
{
m_stopwatch.Start();
var file = await m_folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting).AsTask().ConfigureAwait(false);
await FileIO.WriteBufferAsync(file, imageBuffer).AsTask().ConfigureAwait(false);
m_stopwatch.Stop();
});
}
}
private async Task <SolidColorBrush> GetPixelColor()
{
RenderTargetBitmap retarbi = new RenderTargetBitmap();
await retarbi.RenderAsync(PocketPaintApplication.GetInstance().PaintingAreaCanvas,
(int)PocketPaintApplication.GetInstance().PaintingAreaCanvas.ActualWidth,
(int)PocketPaintApplication.GetInstance().PaintingAreaCanvas.ActualHeight);
Windows.Storage.Streams.IBuffer buffer = await(retarbi.GetPixelsAsync());
var pixels = WindowsRuntimeBufferExtensions.ToArray(buffer);
var width = retarbi.PixelWidth;
var height = retarbi.PixelHeight;
double NormfactorX = (double)width / (double)PocketPaintApplication.GetInstance().Bitmap.PixelWidth;
double NormfactorY = (double)height / (double)PocketPaintApplication.GetInstance().Bitmap.PixelHeight;
double doubleY = ((double)Y) * NormfactorY;
double doubleX = ((double)X) * NormfactorX;
int intX = (int)Math.Round(doubleX, 0);
int intY = (int)Math.Round(doubleY, 0);
int intTemp = intY * width;
int intXTemp = intTemp + intX;
int intValue = intXTemp * 4;
var a = pixels[intValue + 3];
var r = pixels[intValue + 2];
var g = pixels[intValue + 1];
var B = pixels[intValue];
return(new SolidColorBrush(Windows.UI.Color.FromArgb(a, r, g, B)));
}
public IAsyncOperationWithProgress<IBuffer, uint> ReadAsync (IBuffer buffer, uint count, InputStreamOptions options)
{
if (disposed)
throw new ObjectDisposedException(GetType().FullName);
throw new NotImplementedException();
}
internal static IAsyncOperationWithProgress<IBuffer, UInt32> ReadAsync_MemoryStream(Stream stream, IBuffer buffer, UInt32 count)
{
Debug.Assert(stream != null);
Debug.Assert(stream is SREMemoryStream);
Debug.Assert(stream.CanRead);
Debug.Assert(stream.CanSeek);
Debug.Assert(buffer != null);
Debug.Assert(buffer is IBufferByteAccess);
Debug.Assert(0 <= count);
Debug.Assert(count <= Int32.MaxValue);
Debug.Assert(count <= buffer.Capacity);
Contract.EndContractBlock();
// We will return a different buffer to the user backed directly by the memory stream (avoids memory copy).
// This is permitted by the WinRT stream contract.
// The user specified buffer will not have any data put into it:
buffer.Length = 0;
SREMemoryStream memStream = stream as SREMemoryStream;
Debug.Assert(memStream != null);
try
{
IBuffer dataBuffer = memStream.GetWindowsRuntimeBuffer((Int32)memStream.Position, (Int32)count);
if (dataBuffer.Length > 0)
memStream.Seek(dataBuffer.Length, SeekOrigin.Current);
return AsyncInfo.CreateCompletedOperation<IBuffer, UInt32>(dataBuffer);
}
catch (Exception ex)
{
return AsyncInfo.CreateFaultedOperation<IBuffer, UInt32>(ex);
}
} // ReadAsync_MemoryStream
/// <summary>
/// Дешифрования текст
/// </summary>
/// <param name="SourceText">Исходный (шифрованный) текст</param>
/// <param name="InputKey">Ключ шифрования</param>
/// <param name="AlgorytmName">Имя алгоритма дешифрования</param>
///
/// <returns>Расшифрованный (открытый) текст</returns>
public string DecrypMode(string SourceText, string InputKey, string AlgorytmName, string IV, string KeySize)
{
SymmetricKeyAlgorithmProvider Algorithm = SymmetricKeyAlgorithmProvider.OpenAlgorithm(AlgorytmName);
IBuffer KeyBuffer = CryptographicBuffer.ConvertStringToBinary(InputKey, BinaryStringEncoding.Utf16LE);
IBuffer saltBuffer = CryptographicBuffer.ConvertStringToBinary("ll234hl@kljh5:Annc!6002mz", BinaryStringEncoding.Utf16LE);
//CryptoKey = Algorithm.CreateSymmetricKey(keymaterial);
KeyDerivationAlgorithmProvider keyDerivationProvider = KeyDerivationAlgorithmProvider.OpenAlgorithm(KeyDerivationAlgorithmNames.Pbkdf2Sha512);
KeyDerivationParameters pbkdf2Parms = KeyDerivationParameters.BuildForPbkdf2(saltBuffer, 10000);
CryptographicKey keyOriginal = keyDerivationProvider.CreateKey(KeyBuffer);
IBuffer keyMaterial = CryptographicEngine.DeriveKeyMaterial(keyOriginal, pbkdf2Parms,Convert.ToUInt32(KeySize)/8);
// string test= CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf16LE, keyMaterial);
CryptoKey = Algorithm.CreateSymmetricKey(keyMaterial);
if (AlgorytmName.Contains("CBC"))
{
IVBuffer = CryptographicBuffer.ConvertStringToBinary(IV, BinaryStringEncoding.Utf16LE);
}
// Set the data to encrypt.
SourceTextBuffer = CryptographicBuffer.DecodeFromBase64String(SourceText);
// Decrypt
DecryptBuffer = Windows.Security.Cryptography.Core.CryptographicEngine.Decrypt(CryptoKey, SourceTextBuffer, IVBuffer);
DecryptTextOutput = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf16LE, DecryptBuffer);//Надо думать над реализацией Base64
return DecryptTextOutput;
}
public virtual async Task SetAsync(string key, IBuffer buffer, DateTime expires)
{
try
{
var names = key.Split('\\');
var folder = rootFolder;
for (int i = 0; i < names.Length - 1; i++)
{
folder = await folder.CreateFolderAsync(names[i], CreationCollisionOption.OpenIfExists);
}
var file = await folder.CreateFileAsync(names[names.Length - 1], CreationCollisionOption.ReplaceExisting);
await FileIO.WriteBufferAsync(file, buffer);
// Use ImageProperties.DateTaken to store expiration date
var imageProperties = await file.Properties.GetImagePropertiesAsync();
imageProperties.DateTaken = expires;
await imageProperties.SavePropertiesAsync();
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
protected override void OnValueChanged(IBuffer buffer)
{
DataReader wReader = DataReader.FromBuffer(buffer);
using (wReader)
{
byte[] b = new byte[4];
wReader.ReadBytes(b);
var ambientTemperature = BitConverter.ToInt16(b, 2) / 128.0;
double Vobj2 = BitConverter.ToInt16(b, 0);
Vobj2 *= 0.00000015625;
double Tdie = ambientTemperature + 273.15;
double S0 = 5.593E-14;
double a1 = 1.75E-3;
double a2 = -1.678E-5;
double b0 = -2.94E-5;
double b1 = -5.7E-7;
double b2 = 4.63E-9;
double c2 = 13.4;
double Tref = 298.15;
double S = S0 * (1 + a1 * (Tdie - Tref) + a2 * Math.Pow((Tdie - Tref), 2));
double Vos = b0 + b1 * (Tdie - Tref) + b2 * Math.Pow((Tdie - Tref), 2);
double fObj = (Vobj2 - Vos) + c2 * Math.Pow((Vobj2 - Vos), 2);
double tObj = Math.Pow(Math.Pow(Tdie, 4) + (fObj / S), .25);
//CurrentTemperature = tObj - 273.15;
// On retourne plutôt le température ambiante, plus réaliste que temp courante.
CurrentTemperature = ambientTemperature;
}
}
public int dbEncrypt(String partition, int size, String data, out String dataOut)
{
SymmetricKeyAlgorithmProvider SAP = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
CryptographicKey AES;
HashAlgorithmProvider HAP = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
CryptographicHash Hash_AES = HAP.CreateHash();
try{
byte[] hash = new byte[32];
Hash_AES.Append(CryptographicBuffer.CreateFromByteArray(System.Text.Encoding.UTF8.GetBytes(partition)));
byte[] temp;
CryptographicBuffer.CopyToByteArray(Hash_AES.GetValueAndReset(), out temp);
Array.Copy(temp, 0, hash, 0, 16);
Array.Copy(temp, 0, hash, 15, 16);
AES = SAP.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(hash));
Windows.Storage.Streams.IBuffer Buffer = CryptographicBuffer.DecodeFromBase64String(data);
byte[] Decrypted;
CryptographicBuffer.CopyToByteArray(CryptographicEngine.Decrypt(AES, Buffer, null), out Decrypted);
dataOut = System.Text.Encoding.UTF8.GetString(Decrypted, 0, Decrypted.Length);
}
catch (Exception ex)
{
dataOut = "";
return(getErrorCode() == 0 ? 1 : 0);
}
return(getErrorCode() == 0 ? 1 : 0);
}
/// <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 Aes128Pkcs7ReadStream(Stream parent, byte[] key, byte[] iv)
{
if (parent == null)
throw new ArgumentNullException(nameof(parent));
if (key == null)
throw new ArgumentNullException(nameof(key));
if (!parent.CanRead)
throw new ArgumentException("parent must be a readable stream");
_parent = parent;
var algorithm = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbc);
var lastAlgorithm = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
_blockLength = (int)lastAlgorithm.BlockLength;
if (null != iv && iv.Length != _blockLength)
throw new ArgumentOutOfRangeException(nameof(iv), "length must match the block length");
_encryptedBuffer = _encrypted.AsBuffer();
_encryptedBuffer.Length = 0;
var keyBuffer = key.AsBuffer();
_key = algorithm.CreateSymmetricKey(keyBuffer);
_lastKey = lastAlgorithm.CreateSymmetricKey(keyBuffer);
_ivBuffer = CopyArray(iv).AsBuffer();
}
/// <summary>
/// 对字符串依据指定的算法和密钥进行加密，如果使用 CBC 算法，还需要初始化向量
/// </summary>
/// <param name="content">源字符串</param>
/// <param name="strAlgName">加密算法</param>
/// <param name="encoding">字符串编码方式</param>
/// <param name="key">密钥</param>
/// <param name="iniVec">CBC 初始化向量</param>
/// <returns></returns>
public static IBuffer CipherEncryption(string content, string strAlgName,
BinaryStringEncoding encoding, CryptographicKey key, IBuffer iniVec = null)
{
// Create a buffer that contains the encoded message to be encrypted.
IBuffer buffContent = CryptographicBuffer.ConvertStringToBinary(content, encoding);
// Open a symmetric algorithm provider for the specified algorithm.
SymmetricKeyAlgorithmProvider objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(strAlgName);
// Determine whether the message length is a multiple of the block length.
// This is not necessary for PKCS #7 algorithms which automatically pad the
// message to an appropriate length.
if (!strAlgName.Contains("PKCS7"))
{
if ((buffContent.Length % objAlg.BlockLength) != 0)
{
throw new Exception("Message buffer length must be multiple of block length.");
}
}
if (strAlgName.Contains("CBC") && iniVec == null)
{
throw new ArgumentException("Using CBC Encryption, initial vector must have value");
}
// Encrypt the data and return.
IBuffer buffEncrypt = CryptographicEngine.Encrypt(key, buffContent, iniVec);
return buffEncrypt;
}
async public Task <int> preparePaintingAreaCanvasForEraser()
{
RenderTargetBitmap retarbi = new RenderTargetBitmap();
Canvas eraserCanvas = PocketPaintApplication.GetInstance().EraserCanvas;
try
{
if (eraserCanvas.Visibility == Visibility.Collapsed)
{
eraserCanvas.Visibility = Visibility.Visible;
}
await retarbi.RenderAsync(eraserCanvas);
Windows.Storage.Streams.IBuffer buffer = await(retarbi.GetPixelsAsync());
pixelsCanvasEraser = WindowsRuntimeBufferExtensions.ToArray(buffer);
this.pixelHeightCanvas = retarbi.PixelHeight;
this.pixelWidthCanvas = retarbi.PixelWidth;
}
catch
{
return(1);
}
return(0);
}
uint Read(IBuffer buffer, uint offset, uint count)
{
if (this.needSeek) {
if (this.position < 44)
asap.Seek(0);
else {
ulong bytes = this.position - 44 & ~(BufferSize - 1UL);
asap.SeekSample((int) (bytes / wavHeader[32]));
}
this.needSeek = false;
}
ulong left = this.size - this.position;
if (count > left)
count = (uint) left;
if (this.position < 44UL) {
uint n = Math.Min(44 - (uint) this.position, count);
this.wavHeader.CopyTo((int) this.position, buffer, offset, (int) n);
this.position += n;
offset += n;
count -= n;
}
while (count > 0) {
int i = (int) this.position - 44 & BufferSize - 1;
if (i == 0)
asap.Generate(this.samples, BufferSize, ASAPSampleFormat.S16LE);
uint n = Math.Min((uint) BufferSize - (uint) i, count);
this.samples.CopyTo(i, buffer, offset, (int) n);
this.position += n;
offset += n;
count -= n;
}
return offset;
}
public async Task GetNewFrameAndApplyEffect(IBuffer frameBuffer, Size frameSize)
{
if (_semaphore.WaitOne(500))
{
var scanlineByteSize = (uint)frameSize.Width * 4; // 4 bytes per pixel in BGRA888 mode
var bitmap = new Bitmap(frameSize, ColorMode.Bgra8888, scanlineByteSize, frameBuffer);
try
{
if (_blendEffect != null)
{
_blendEffect.GlobalAlpha = GlobalAlpha;
var renderer = new BitmapRenderer(_blendEffect, bitmap);
await renderer.RenderAsync();
}
else
{
var renderer = new BitmapRenderer(_cameraPreviewImageSource, bitmap);
await renderer.RenderAsync();
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("RealtimeBlendDemo.GetNewFrameAndApplyEffect(): "
+ ex.ToString());
}
_semaphore.Release();
}
}
public PixelBufferInfo(IBuffer pixelBuffer)
{
this.pixelStream = WindowsRuntimeBufferExtensions.AsStream(pixelBuffer);
this.Bytes = new byte[this.pixelStream.Length];
this.pixelStream.Seek(0L, SeekOrigin.Begin);
this.pixelStream.Read(this.Bytes, 0, this.Bytes.Length);
}
public async Task GetNewFrameAndApplyEffect(IBuffer frameBuffer, Size frameSize)
{
if (_semaphore.WaitOne(500))
{
var scanlineByteSize = (uint)frameSize.Width * 4; // 4 bytes per pixel in BGRA888 mode
var bitmap = new Bitmap(frameSize, ColorMode.Bgra8888, scanlineByteSize, frameBuffer);
if (_filterEffect != null)
{
var renderer = new BitmapRenderer(_filterEffect, bitmap);
await renderer.RenderAsync();
}
else if (_customEffect != null)
{
var renderer = new BitmapRenderer(_customEffect, bitmap);
await renderer.RenderAsync();
}
else
{
var renderer = new BitmapRenderer(_cameraPreviewImageSource, bitmap);
await renderer.RenderAsync();
}
_semaphore.Release();
}
}
public static byte[] ToBytes(IBuffer value)
{
if(value == null)
throw new ArgumentException();
var temp = new byte[value.Length];
DataReader.FromBuffer(value).ReadBytes(temp);
return temp;
}
// Gets a byte array from a buffer
public static byte[] ReadBufferToBytes(IBuffer buffer)
{
var dataLength = buffer.Length;
var data = new byte[dataLength];
var reader = DataReader.FromBuffer(buffer);
reader.ReadBytes(data);
return data;
}
public static void CopyTo(this Byte[] source, IBuffer destination)
{
if (source == null) throw new ArgumentNullException("source");
if (destination == null) throw new ArgumentNullException("destination");
Contract.EndContractBlock();
CopyTo(source, 0, destination, 0, source.Length);
}
public PixelBufferInfo(IBuffer pixelBuffer)
{
this.pixelStream = pixelBuffer.AsStream();
this.Bytes = new byte[this.pixelStream.Length];
this.pixelStream.Seek(0, SeekOrigin.Begin);
this.pixelStream.Read(this.Bytes, 0, Bytes.Length);
//this.Pixels = bytes.ToPixels();
}
public static IBuffer Decrypt(IBuffer input, string password = "******")
{
var iv = CreateInitializationVector(password);
var key = CreateKey(password);
var decryptedBuffer = CryptographicEngine.Decrypt(
key, input, iv);
return decryptedBuffer;
}
public MP3Extract(IBuffer mp3, Image cover)
{
this.mp3 = mp3;
fileData.Add("Album", "");
fileData.Add("Title", "");
fileData.Add("Artist", "");
data = DataReader.FromBuffer(mp3);
this.cover = cover;
}
// Multiple
public static string ParseUInt8Multi(IBuffer buffer)
{
var bytes = ReadBufferToBytes(buffer);
var result = "";
foreach (var b in bytes) {
result += Convert.ToString(b);
}
return result;
}
public static string getStringFromBuffer(IBuffer buffer)
{
using (DataReader dataReader = DataReader.FromBuffer(buffer))
{
byte[] bufferBytes = new byte[buffer.Length];
dataReader.ReadBytes(bufferBytes);
return (Convert.ToBase64String(bufferBytes));
}
}
public void Append (IBuffer Data)
{
if (Data == null)
return;
WindowsRuntimeBuffer buffer = (WindowsRuntimeBuffer)Data;
throw new NotImplementedException();
}
public CryptographicKey CreateSymmetricKey (IBuffer keyMaterial)
{
if (keyMaterial == null)
throw new COMException ("Invalid key material", -1073741811);
WindowsRuntimeBuffer buffer = (WindowsRuntimeBuffer)keyMaterial;
throw new NotImplementedException();
}
/// <summary>
/// Decrypts the specified input stream.
/// </summary>
/// <param name="input">The input stream.</param>
/// <param name="masterKey">The master key.</param>
/// <param name="headers">The database file headers.</param>
/// <returns>The decrypted buffer.</returns>
/// <exception cref="ArgumentNullException">
/// The <paramref name="input"/>, <paramref name="masterKey"/>,
/// <paramref name="headers"/> cannot be <c>null</c>.
/// </exception>
public static Task<IInputStream> Decrypt(IRandomAccessStream input,
IBuffer masterKey, FileHeaders headers)
{
if (headers == null)
throw new ArgumentNullException("headers");
return Decrypt(input, masterKey,
headers.MasterSeed, headers.EncryptionIV);
}
protected override async void Loop()
{
Streams.DataReader reader = null;
try
{
while (true)
{
if (socket == null)
{
socket = new StreamSocket();
await socket.ConnectAsync(new HostName(DroneClient.Host), _ServiceName);
}
var readBuf = new Streams.Buffer((uint)NetworkBufferSize);
var readOp = socket.InputStream.ReadAsync(readBuf, (uint)NetworkBufferSize, Streams.InputStreamOptions.Partial);
readOp.Completed = (IAsyncOperationWithProgress <Streams.IBuffer, uint> asyncAction, AsyncStatus asyncStatus) =>
{
switch (asyncStatus)
{
case AsyncStatus.Completed:
Debug.WriteLine("Config:Completed ");
try
{
Streams.IBuffer localBuf = asyncAction.GetResults();
uint bytesRead = localBuf.Length;
Debug.WriteLine("Config:Buffer (" + bytesRead + ")");
reader = Streams.DataReader.FromBuffer(localBuf);
OnDataReadCompletion(bytesRead, reader);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
break;
case AsyncStatus.Canceled:
Debug.WriteLine("Config:Canceled ");
break;
case AsyncStatus.Error:
Debug.WriteLine("Config:Error ");
break;
}
};
//socket.Dispose();
await Task.Delay(500);
}
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
Stop();
}
}
public static IBuffer EncryptString(String strMsg,
CryptographicKey key,
out IBuffer iv,
String AlgorithmName = null)
{
// Create a buffer that contains the encoded message to be encrypted.
var buffMsg = CryptographicBuffer.ConvertStringToBinary(strMsg, BinaryStringEncoding.Utf8);
//encrypt
return Encrypt(buffMsg, key, out iv, AlgorithmName: AlgorithmName);
}
public async void Start()
{
var listener = new StreamSocketListener();
var XmlHandler = new XmlHandler();
XmlHandler.MainAsync();
await listener.BindServiceNameAsync("8081");
listener.ConnectionReceived += async(sender, args) =>
{
var request = new StringBuilder();
using (var input = args.Socket.InputStream)
{
var data = new byte[BufferSize];
Windows.Storage.Streams.IBuffer buffer = data.AsBuffer();
var dataRead = BufferSize;
while (dataRead == BufferSize)
{
await input.ReadAsync(
buffer, BufferSize, InputStreamOptions.Partial);
request.Append(Encoding.UTF8.GetString(
data, 0, data.Length));
dataRead = buffer.Length;
}
}
//string query = GetQuery(request);
string query = await XmlHandler.RunQuery(GetQuery(request));
using (var output = args.Socket.OutputStream)
{
using (var response = output.AsStreamForWrite())
{
var html = Encoding.UTF8.GetBytes(
$"<html><head><title>Background Message</title></head><body>{query}</body></html>");
using (var bodyStream = new MemoryStream(html))
{
var header = $"HTTP/1.1 200 OK\r\nContent-Length: {bodyStream.Length}\r\nConnection: close\r\n\r\n";
var headerArray = Encoding.UTF8.GetBytes(header);
await response.WriteAsync(headerArray,
0, headerArray.Length);
await bodyStream.CopyToAsync(response);
await response.FlushAsync();
}
}
}
};
}
public int setDbCryptKey(String partition, String key, bool bPersistent)
{
Windows.Storage.Streams.IBuffer keyByte = Encoding.UTF8.GetBytes(key).AsBuffer();
DataProtectionProvider protecotor = new DataProtectionProvider();
IAsyncOperation <IBuffer> task = protecotor.ProtectAsync(keyByte);
task.AsTask().Wait();
Windows.Storage.Streams.IBuffer protectedKeyByte = task.GetResults();
this.writeKeyToFile(partition, protectedKeyByte.ToArray());
return(getErrorCode() == 0 ? 1 : 0);
}
async public Task <int> preparePaintingAreaCanvasPixel()
{
RenderTargetBitmap retarbi = new RenderTargetBitmap();
Canvas canvas = PocketPaintApplication.GetInstance().PaintingAreaCanvas;
await retarbi.RenderAsync(canvas);
Windows.Storage.Streams.IBuffer buffer = await(retarbi.GetPixelsAsync());
pixelsCanvas = WindowsRuntimeBufferExtensions.ToArray(buffer);
this.pixelHeightCanvas = retarbi.PixelHeight;
this.pixelWidthCanvas = retarbi.PixelWidth;
return(0);
}
private async Task <Windows.Storage.Streams.IRandomAccessStream> toStream(Windows.Storage.Streams.IBuffer ibuffer)
{
var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var outputStream = stream.GetOutputStreamAt(0);
var datawriter = new Windows.Storage.Streams.DataWriter(outputStream);
datawriter.WriteBuffer(ibuffer);
await datawriter.StoreAsync();
await outputStream.FlushAsync();
return(stream);
}
private static MiDeviceData ReadDatas(Windows.Storage.Streams.IBuffer buffer)
{
var data = ExtractBytesFromBuffer(buffer);
byte[] readableValue = data.ToArray();
double temperature = ((readableValue[1] & 0x7F) << 8 | readableValue[0]) / 100.0;
byte moisture = readableValue[2];
return(new MiDeviceData()
{
Temperature = temperature,
Moisture = moisture
});
}
private static byte[] ExtractBytesFromBuffer(Windows.Storage.Streams.IBuffer buffer)
{
List <byte> data = new List <byte>(capacity: (int)buffer.Length);
using (Windows.Storage.Streams.DataReader dr = Windows.Storage.Streams.DataReader.FromBuffer(buffer))
{
while (dr.UnconsumedBufferLength > 0)
{
data.Add(dr.ReadByte());
}
}
return(data.ToArray());
}
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);
}
private byte[] HandleReceive(uint bytesRead, DataReader readPacket, int length = 1024 *1024 *5)
{
var bufferSpace = length * 2;
byte[] tmpRet = new byte[length];
Windows.Storage.Streams.IBuffer ibuffer = readPacket.ReadBuffer(readPacket.UnconsumedBufferLength);
Byte[] convBuffer = WindowsRuntimeBufferExtensions.ToArray(ibuffer);
if (bytesRead > 0)
{
System.Buffer.BlockCopy(convBuffer, 0, tmpRet, (int)0, (int)length);
}
_transferredSize += bytesRead;
var kucing = System.Text.Encoding.UTF8.GetString(tmpRet, 0, tmpRet.Length);
WhatsAPI.UniversalApps.Libs.Utils.Logger.Log.WriteLog("Receive Message => " + System.Text.Encoding.UTF8.GetString(tmpRet, 0, tmpRet.Length));
return(tmpRet);
}
public void UpdateData(Windows.Storage.Streams.IBuffer buffer)
{
this.data = buffer.ToArray();
ParseData();
}
public bool Start()
{
try
{
StreamSocketListener listener = new StreamSocketListener();
listener.BindServiceNameAsync("80").AsTask();
listener.ConnectionReceived += async(sender, args) =>
{
StringBuilder request = new StringBuilder();
using (Windows.Storage.Streams.IInputStream input = args.Socket.InputStream)
{
byte[] data = new byte[BufferSize];
Windows.Storage.Streams.IBuffer buffer = data.AsBuffer();
uint dataRead = BufferSize;
while (dataRead == BufferSize)
{
await input.ReadAsync(buffer, BufferSize, InputStreamOptions.Partial);
request.Append(Encoding.UTF8.GetString(data, 0, data.Length));
dataRead = buffer.Length;
}
//In the future, maybe we parse the HTTP request and serve different HTML pages for now we just always push index.html
}
using (IOutputStream output = args.Socket.OutputStream)
{
using (System.IO.Stream response = output.AsStreamForWrite())
{
string page = "";
var folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
// acquire file
var file = await folder.GetFileAsync("index.html");
var readFile = await Windows.Storage.FileIO.ReadLinesAsync(file);
foreach (var line in readFile)
{
page += line;
}
byte[] bodyArray = Encoding.UTF8.GetBytes(page);
var bodyStream = new MemoryStream(bodyArray);
//iCount++;
var header = "HTTP/1.1 200 OK\r\n" +
$"Content-Length: {bodyStream.Length}\r\n" +
"Connection: close\r\n\r\n";
byte[] headerArray = Encoding.UTF8.GetBytes(header);
await response.WriteAsync(headerArray, 0, headerArray.Length);
await bodyStream.CopyToAsync(response);
await response.FlushAsync();
}
}
};
return(true);
}
catch (Exception e)
{
return(false);
}
}
public IAsyncOperationWithProgress <IBuffer, uint> ReadAsync(IBuffer buffer, uint count, InputStreamOptions options) => _stream.ReadAsync(buffer, count, options);
public IAsyncOperationWithProgress <uint, uint> WriteAsync(IBuffer buffer) => _stream.WriteAsync(buffer);
} // ReadAsync_AbstractStream
#endregion ReadAsync implementations
#region WriteAsync implementations
internal static IAsyncOperationWithProgress <uint, uint> WriteAsync_AbstractStream(Stream stream, IBuffer buffer)
{
Debug.Assert(stream != null);
Debug.Assert(stream.CanWrite);
Debug.Assert(buffer != null);
// Choose the optimal writing strategy for the kind of buffer supplied:
Func <CancellationToken, IProgress <uint>, Task <uint> > writeOperation;
byte[] data;
int offset;
// If buffer is backed by a managed array:
if (buffer.TryGetUnderlyingData(out data, out offset))
{
writeOperation = async(cancelToken, progressListener) =>
{
if (cancelToken.IsCancellationRequested) // CancellationToken is non-nullable
{
return(0);
}
Debug.Assert(buffer.Length <= int.MaxValue);
int bytesToWrite = (int)buffer.Length;
await stream.WriteAsync(data, offset, bytesToWrite, cancelToken).ConfigureAwait(continueOnCapturedContext: false);
if (progressListener != null)
{
progressListener.Report((uint)bytesToWrite);
}
return((uint)bytesToWrite);
};
// Otherwise buffer is of an unknown implementation:
}
else
{
writeOperation = async(cancelToken, progressListener) =>
{
if (cancelToken.IsCancellationRequested) // CancellationToken is non-nullable
{
return(0);
}
uint bytesToWrite = buffer.Length;
Stream dataStream = buffer.AsStream();
int buffSize = 0x4000;
if (bytesToWrite < buffSize)
{
buffSize = (int)bytesToWrite;
}
if (buffSize > 0)
{
await dataStream.CopyToAsync(stream, buffSize, cancelToken).ConfigureAwait(continueOnCapturedContext: false);
}
if (progressListener != null)
{
progressListener.Report((uint)bytesToWrite);
}
return((uint)bytesToWrite);
};
} // if-else
// Construct and run the async operation:
return(AsyncInfo.Run <uint, uint>(writeOperation));
} // WriteAsync_AbstractStream
internal static IAsyncOperationWithProgress <IBuffer, uint> ReadAsync_MemoryStream(Stream stream, IBuffer buffer, uint count)
{
Debug.Assert(stream != null);
Debug.Assert(stream is MemoryStream);
Debug.Assert(stream.CanRead);
Debug.Assert(stream.CanSeek);
Debug.Assert(buffer != null);
Debug.Assert(0 <= count);
Debug.Assert(count <= int.MaxValue);
Debug.Assert(count <= buffer.Capacity);
// We will return a different buffer to the user backed directly by the memory stream (avoids memory copy).
// This is permitted by the WinRT stream contract.
// The user specified buffer will not have any data put into it:
buffer.Length = 0;
MemoryStream memStream = stream as MemoryStream;
Debug.Assert(memStream != null);
try
{
IBuffer dataBuffer = memStream.GetWindowsRuntimeBuffer((int)memStream.Position, (int)count);
if (dataBuffer.Length > 0)
{
memStream.Seek(dataBuffer.Length, SeekOrigin.Current);
}
return(AsyncInfo.CreateCompletedOperation <IBuffer, uint>(dataBuffer));
}
catch (Exception ex)
{
return(AsyncInfo.CreateFaultedOperation <IBuffer, uint>(ex));
}
} // ReadAsync_MemoryStream
} // ReadAsync_MemoryStream
internal static IAsyncOperationWithProgress <IBuffer, uint> ReadAsync_AbstractStream(Stream stream, IBuffer buffer, uint count,
InputStreamOptions options)
{
Debug.Assert(stream != null);
Debug.Assert(stream.CanRead);
Debug.Assert(buffer != null);
Debug.Assert(0 <= count);
Debug.Assert(count <= int.MaxValue);
Debug.Assert(count <= buffer.Capacity);
Debug.Assert(options == InputStreamOptions.None || options == InputStreamOptions.Partial || options == InputStreamOptions.ReadAhead);
int bytesrequested = (int)count;
// Check if the buffer is our implementation.
// IF YES: In that case, we can read directly into its data array.
// IF NO: The buffer is of unknown implementation. It's not backed by a managed array, but the wrapped stream can only
// read into a managed array. If we used the user-supplied buffer we would need to copy data into it after every read.
// The spec allows to return a buffer instance that is not the same as passed by the user. So, we will create an own
// buffer instance, read data *directly* into the array backing it and then return it to the user.
// Note: the allocation costs we are paying for the new buffer are unavoidable anyway, as we would need to create
// an array to read into either way.
IBuffer dataBuffer = buffer as WindowsRuntimeBuffer;
if (dataBuffer == null)
{
dataBuffer = WindowsRuntimeBuffer.Create((int)Math.Min((uint)int.MaxValue, buffer.Capacity));
}
// This operation delegate will we run inside of the returned IAsyncOperationWithProgress:
Func <CancellationToken, IProgress <uint>, Task <IBuffer> > readOperation = async(cancelToken, progressListener) =>
{
// No bytes read yet:
dataBuffer.Length = 0;
// Get the buffer backing array:
byte[] data;
int offset;
bool managedBufferAssert = dataBuffer.TryGetUnderlyingData(out data, out offset);
Debug.Assert(managedBufferAssert);
// Init tracking values:
bool done = cancelToken.IsCancellationRequested;
int bytesCompleted = 0;
// Loop until EOS, cancelled or read enough data according to options:
while (!done)
{
int bytesread = 0;
try
{
// Read asynchronously:
bytesread = await stream.ReadAsync(data !, offset + bytesCompleted, bytesrequested - bytesCompleted, cancelToken)
.ConfigureAwait(continueOnCapturedContext: false);
// We will continue here on a different thread when read async completed:
bytesCompleted += bytesread;
// We will handle a cancelation exception and re-throw all others:
}
catch (OperationCanceledException)
{
// We assume that cancelToken.IsCancellationRequested is has been set and simply proceed.
// (we check cancelToken.IsCancellationRequested later)
Debug.Assert(cancelToken.IsCancellationRequested);
// This is because if the cancellation came after we read some bytes we want to return the results we got instead
// of an empty cancelled task, so if we have not yet read anything at all, then we can throw cancellation:
if (bytesCompleted == 0 && bytesread == 0)
{
throw;
}
}
// Update target buffer:
dataBuffer.Length = (uint)bytesCompleted;
Debug.Assert(bytesCompleted <= bytesrequested);
// Check if we are done:
done = options == InputStreamOptions.Partial || // If no complete read was requested, any amount of data is OK
bytesread == 0 || // this implies EndOfStream
bytesCompleted == bytesrequested || // read all requested bytes
cancelToken.IsCancellationRequested; // operation was cancelled
// Call user Progress handler:
if (progressListener != null)
{
progressListener.Report(dataBuffer.Length);
}
} // while (!done)
// If we got here, then no error was detected. Return the results buffer:
return(dataBuffer);
}; // readOperation
return(AsyncInfo.Run <IBuffer, uint>(readOperation));
} // ReadAsync_AbstractStream
/// <summary>
/// 把图片保存到本地临时文件夹中
/// </summary>
/// <param name="file"></param>
/// <param name="buffer"></param>
/// <returns></returns>
public async Task SaveFile(StorageFile file, Windows.Storage.Streams.IBuffer buffer)
{
await Windows.Storage.FileIO.WriteBufferAsync(file, buffer);
}
