public static string AES_Decrypt(string input, string pass) { //opposite process string[] strInput = input.Split('!'); //Split IV and cyphertext IBuffer BufferIV = CryptographicBuffer.DecodeFromBase64String(strInput[1]); SymmetricKeyAlgorithmProvider SAP = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7); CryptographicKey AES; HashAlgorithmProvider HAP = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5); CryptographicHash Hash_AES = HAP.CreateHash(); string decrypted = ""; try { byte[] hash = new byte[32]; Hash_AES.Append(CryptographicBuffer.CreateFromByteArray(System.Text.Encoding.UTF8.GetBytes(pass))); byte[] temp; CryptographicBuffer.CopyToByteArray(Hash_AES.GetValueAndReset(), out temp); Array.Copy(temp, 0, hash, 0, 16); Array.Copy(temp, 0, hash, 16, 16); //temp->hash AES = SAP.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(hash)); IBuffer Buffer = CryptographicBuffer.DecodeFromBase64String(strInput[0]); byte[] Decrypted; CryptographicBuffer.CopyToByteArray(CryptographicEngine.Decrypt(AES, Buffer, BufferIV), out Decrypted); decrypted = System.Text.Encoding.UTF8.GetString(Decrypted, 0, Decrypted.Length); return(decrypted); } catch (Exception ex) { return(null); } #endregion }
private CryptographicHash CreateHmacCryptographicHash() { String algName = AlgorithmNames.SelectionBoxItem.ToString(); // Create a HashAlgorithmProvider object. MacAlgorithmProvider Algorithm = MacAlgorithmProvider.OpenAlgorithm(algName); IBuffer vector = CryptographicBuffer.DecodeFromBase64String("uiwyeroiugfyqcajkds897945234=="); HashingText.Text += "\n*** Sample Hash Algorithm: " + Algorithm.AlgorithmName + "\n"; HashingText.Text += " Initial vector: uiwyeroiugfyqcajkds897945234==\n"; IBuffer hmacKeyMaterial = CryptographicBuffer.GenerateRandom(Algorithm.MacLength); // Compute the hash in one call. CryptographicHash hash = Algorithm.CreateHash(hmacKeyMaterial); hash.Append(vector); digest = hash.GetValueAndReset(); HashingText.Text += " Hash: " + CryptographicBuffer.EncodeToHexString(digest) + "\n"; return(Algorithm.CreateHash(hmacKeyMaterial)); }
/// <summary> /// Verifies the database file headers integrity. /// </summary> /// <param name="headerHash">The database file headers hash.</param> /// <param name="doc">The database content.</param> /// <returns><c>true</c> if the header is valid; otherwise, <c>false</c>.</returns> /// <exception cref="ArgumentNullException"> /// The <paramref name="headerHash"/> and <paramref name="doc"/> cannot be <c>null</c>. /// </exception> public static bool VerifyHeaders(IBuffer headerHash, XDocument doc) { string meta; try { meta = doc .Elements("KeePassFile") .Elements("Meta") .Elements("HeaderHash") .Select(x => x.Value) .Single(); } catch (InvalidOperationException) { return(false); } var expected = CryptographicBuffer .DecodeFromBase64String(meta); return(CryptographicBuffer.Compare(expected, headerHash)); }
public static byte[] Encrypt(byte[] data, string keyString) { //初始化加密算法provider,使用DES_ECB_PKCS7算法 SymmetricKeyAlgorithmProvider symmetricProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.Rc4); //根据keystring生成key IBuffer key = CryptographicBuffer.DecodeFromBase64String(keyString); CryptographicKey cryKey = symmetricProvider.CreateSymmetricKey(key); //加密数据 IBuffer buffer = CryptographicBuffer.CreateFromByteArray(data); try { var encrypted = CryptographicEngine.Encrypt(cryKey, buffer, null); buffer.AsStream().Dispose(); return(encrypted.ToArray()); } catch (Exception) { throw; } }
public static string AES_Decrypt(string input, string pass) { if (string.IsNullOrEmpty(input)) { return(null); } SymmetricKeyAlgorithmProvider SAP = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7); CryptographicKey AES; HashAlgorithmProvider HAP = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5); CryptographicHash Hash_AES = HAP.CreateHash(); string decrypted = string.Empty; try { byte[] hash = new byte[32]; Hash_AES.Append(CryptographicBuffer.CreateFromByteArray(System.Text.Encoding.UTF8.GetBytes(pass))); 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)); IBuffer Buffer = CryptographicBuffer.DecodeFromBase64String(input); byte[] Decrypted; CryptographicBuffer.CopyToByteArray(CryptographicEngine.Decrypt(AES, Buffer, null), out Decrypted); decrypted = System.Text.Encoding.UTF8.GetString(Decrypted, 0, Decrypted.Length); return(decrypted); } catch { throw new T360Exception(T360ErrorCodes.DecryptionFailed); } }
private CryptographicHash CreateHashCryptographicHash() { String algName = AlgorithmNames.SelectionBoxItem.ToString(); // Create a HashAlgorithmProvider object. HashAlgorithmProvider Algorithm = HashAlgorithmProvider.OpenAlgorithm(algName); IBuffer vector = CryptographicBuffer.DecodeFromBase64String("uiwyeroiugfyqcajkds897945234=="); HashingText.Text += "\n*** Sample Hash Algorithm: " + Algorithm.AlgorithmName + "\n"; HashingText.Text += " Initial vector: uiwyeroiugfyqcajkds897945234==\n"; // Compute the hash in one call. digest = Algorithm.HashData(vector); if (digest.Length != Algorithm.HashLength) { HashingText.Text += "HashAlgorithmProvider failed to generate a hash of proper length!\n"; return(null); } HashingText.Text += " Hash: " + CryptographicBuffer.EncodeToHexString(digest) + "\n"; return(Algorithm.CreateHash()); }
public static string Decrypt(string encryptedData, string pw, string iv) { try { IBuffer pwBuffer = CryptographicBuffer.ConvertStringToBinary(pw, BinaryStringEncoding.Utf8); IBuffer ivBuffer = CryptographicBuffer.ConvertStringToBinary(iv, BinaryStringEncoding.Utf16LE); IBuffer cipherBuffer = CryptographicBuffer.DecodeFromBase64String(encryptedData); // Derive key material for password size 32 bytes for AES256 algorithm KeyDerivationAlgorithmProvider keyDerivationProvider = KeyDerivationAlgorithmProvider.OpenAlgorithm("PBKDF2_SHA1"); // using IV and 1000 iterations KeyDerivationParameters pbkdf2Parms = KeyDerivationParameters.BuildForPbkdf2(ivBuffer, 1000); // create a key based on original key and derivation parmaters CryptographicKey keyOriginal = keyDerivationProvider.CreateKey(pwBuffer); IBuffer keyMaterial = CryptographicEngine.DeriveKeyMaterial(keyOriginal, pbkdf2Parms, 32); CryptographicKey derivedPwKey = keyDerivationProvider.CreateKey(pwBuffer); // derive buffer to be used for encryption iv from derived password key IBuffer ivMaterial = CryptographicEngine.DeriveKeyMaterial(derivedPwKey, pbkdf2Parms, 16); SymmetricKeyAlgorithmProvider symProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm("AES_CBC_PKCS7"); // create symmetric key from derived password material CryptographicKey symmKey = symProvider.CreateSymmetricKey(keyMaterial); // decrypt data buffer using symmetric key and derived IV material IBuffer resultBuffer = CryptographicEngine.Decrypt(symmKey, cipherBuffer, ivMaterial); string result = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf16LE, resultBuffer); return(result); } catch (System.Exception) { System.Diagnostics.Debug.WriteLine("Failed to decrypt file. Throwing exception up the chain."); throw; } }
private async Task <Result> SignInWithWindowsHelloAsync() { string userName = AppSettings.Current.UserName; if (IsWindowsHelloEnabled(userName)) { var retrieveResult = await KeyCredentialManager.OpenAsync(userName); if (retrieveResult.Status == KeyCredentialStatus.Success) { var credential = retrieveResult.Credential; var challengeBuffer = CryptographicBuffer.DecodeFromBase64String("challenge"); var result = await credential.RequestSignAsync(challengeBuffer); if (result.Status == KeyCredentialStatus.Success) { return(Result.Ok()); } return(Result.Error("Windows Hello", $"Cannot sign in with Windows Hello: {result.Status}")); } return(Result.Error("Windows Hello", $"Cannot sign in with Windows Hello: {retrieveResult.Status}")); } return(Result.Error("Windows Hello", "Windows Hello is not enabled for current user.")); }
/// <summary> /// Decypts a string using a key signed by a KeyCredential. /// </summary> /// <param name="strProtected">Text to decrypt.</param> /// <param name="rResult">KeyCredential object used to sign a key to encrypt the text.</param> /// <returns>Decrypted text.</returns> internal static async Task <ProtectedString> Decrypt(string strProtected, KeyCredentialRetrievalResult rResult) { // The same text must be used to decrypt the data Assembly assembly = Assembly.GetExecutingAssembly(); var attribute = (GuidAttribute)assembly.GetCustomAttributes(typeof(GuidAttribute), true)[0]; var id = attribute.Value; IBuffer buffMsg = CryptographicBuffer.ConvertStringToBinary(id, encoding); // Start a background thread to ensure Windows Security prompt is opened in foreground var _ = Task.Factory.StartNew(() => EnsureForeground()); // The actual Signing of the string KeyCredentialOperationResult opResult = await rResult.Credential.RequestSignAsync(buffMsg); if (opResult.Status == KeyCredentialStatus.Success) { IBuffer signedData = opResult.Result; // Creation of the key with the signed string SymmetricKeyAlgorithmProvider provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7); CryptographicKey myKey = provider.CreateSymmetricKey(signedData); // Decryption of the data using the key created (mKey) IBuffer buffProtected = CryptographicBuffer.DecodeFromBase64String(strProtected); CryptographicBuffer.CopyToByteArray(CryptographicEngine.Decrypt(myKey, buffProtected, null), out var ba); ProtectedString ps = new ProtectedString(true, ba); MemUtil.ZeroByteArray(ba); return(ps); } else { WinHelloUnlockExt.opened = true; WinHelloErrors(opResult.Status, "Error decrypting the data: "); return(null); } }
/// <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 IBuffer decode64BaseString(string str) { IBuffer buffFromBase64String = CryptographicBuffer.DecodeFromBase64String(str); return(buffFromBase64String); }
public async void downloadFile(StorageFolder folder, string filename, IList <string> chunkNameList, IList <string> chunkIdList, IList <string> providerNameList, IList <string> providerTokenList, IList <string> cloudFolderList) { // Store the result of chunk downloads _result = new List <string>(); // Convert lists to arrays string[] chunkNames = new string[chunkNameList.Count]; chunkNameList.CopyTo(chunkNames, 0); string[] chunkIds = new string[chunkIdList.Count]; chunkIdList.CopyTo(chunkIds, 0); string[] providerNames = new string[providerNameList.Count]; providerNameList.CopyTo(providerNames, 0); string[] providerTokens = new string[providerTokenList.Count]; providerTokenList.CopyTo(providerTokens, 0); string[] cloudFolders = new string[cloudFolderList.Count]; cloudFolderList.CopyTo(cloudFolders, 0); int chunkIdx = 0; try { // Open the stream to write DataWriter writer; IRandomAccessStream stream = null; if (filename == "trustydrive_metadata") { //DO NOT write the metadata to a file stream = new InMemoryRandomAccessStream(); writer = new DataWriter(stream); } else { StorageFile file = await folder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); stream = await file.OpenAsync(FileAccessMode.ReadWrite); writer = new DataWriter(stream.GetOutputStreamAt(0)); } int currentResult; int downloadIdx; while (chunkIdx < chunkNames.Length) { currentResult = _result.Count; // TODO Refactoring to increase the number of concurrent downloads _downloads = new DownloadedChunk[5 * providerNames.Length]; for (downloadIdx = 0; downloadIdx < 5 * providerNames.Length && chunkIdx < chunkNames.Length; downloadIdx++, chunkIdx++) { int providerIdx = downloadIdx % providerNames.Length; switch (providerNames[providerIdx]) { case "dropbox": case "onedrive": downloadAsync(chunkNames[chunkIdx], providerNames[providerIdx], providerTokens[providerIdx], cloudFolders[providerIdx], downloadIdx); break; case "gdrive": downloadAsync(chunkIds[chunkIdx], providerNames[providerIdx], providerTokens[providerIdx], cloudFolders[providerIdx], downloadIdx); break; } } // Wait the end of the downloads while (_result.Count < currentResult + downloadIdx) { await Task.Delay(TimeSpan.FromMilliseconds(500)); } // Write the file by putting chunks together for (int d = 0; d < downloadIdx; d += providerNames.Length) { for (int i = 0; i < _downloads[d].size; i++) { for (int j = d; j < d + providerNames.Length; j++) { if (i < _downloads[j].size) { writer.WriteByte(_downloads[j].readByte()); } } } } for (int d = 0; d < downloadIdx; d++) { _downloads[d].close(); } } await writer.StoreAsync(); await writer.FlushAsync(); if (filename == "trustydrive_metadata") { // We just download the metadata DataReader reader = new DataReader(stream.GetInputStreamAt(0)); reader.UnicodeEncoding = UnicodeEncoding.Utf8; reader.ByteOrder = ByteOrder.LittleEndian; await reader.LoadAsync((uint)stream.Size); metadata = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, reader.ReadBuffer((uint)stream.Size)); metadata = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, CryptographicBuffer.DecodeFromBase64String(metadata)); } else { stream.Dispose(); } writer.Dispose(); _downloaded = true; } catch { _result.Add("error"); } }
/// <summary> /// Decodes an instance from serialized XML. /// </summary> /// <param name="xml">The XML to deserialize.</param> /// <param name="parameters">Parameters controlling serialization.</param> public KdbxBinary(XElement xml, KdbxSerializationParameters parameters) { // Parse out int ID attribute string idAttr = xml?.Attribute("ID")?.Value; if (idAttr == null) { throw new KdbxParseException( ReaderResult.FromXmlParseFailure($"KdbxBinary was missing required ID attribute") ); } if (!Int32.TryParse(idAttr, out int id)) { throw new KdbxParseException( ReaderResult.FromXmlParseFailure($"KdbxBinary ID attribute could not be parsed into an int") ); } Id = id; // Parse out bool Compressed attribute string compressAttr = xml?.Attribute("Compressed")?.Value ?? "false"; if (!Boolean.TryParse(compressAttr, out bool compressed)) { throw new KdbxParseException( ReaderResult.FromXmlParseFailure($"KdbxBinary Compressed attribute could not be parsed into a bool") ); } // Parse base64-encoded content byte[] content; try { content = CryptographicBuffer.DecodeFromBase64String(xml?.Value)?.ToArray(); if (content == null) { content = new byte[0]; } } catch (Exception) { throw new KdbxParseException( ReaderResult.FromXmlParseFailure($"Could not decode KdbxBinary content as base64 data") ); } // Decompress content if needed if (compressed && content.Length > 0) { byte[] decompressed; using (Stream memStream = new MemoryStream(content)) { using (Stream gzipStream = new GZipStream(memStream, CompressionMode.Decompress)) { byte[] buffer = new byte[1024]; int read = gzipStream.Read(buffer, 0, buffer.Length); List <byte> bytes = new List <byte>(); while (read > 0) { bytes.AddRange(buffer.Take(read)); read = gzipStream.Read(buffer, 0, buffer.Length); } decompressed = bytes.ToArray(); } } content = decompressed; } this.binaryData = new ProtectedBinary(content, false); }
public static async Task <bool> SignInWithHelloAsync(string userId, KeyCredentialRetrievalResult retrieveResult = null) { // Open the existing user key credential. if (retrieveResult == null) { retrieveResult = await KeyCredentialManager.OpenAsync(userId); } if (retrieveResult.Status != KeyCredentialStatus.Success) { return(false); } KeyCredential userCredential = retrieveResult.Credential; string publicKeyHint = CalculatePublicKeyHint(userCredential.RetrievePublicKey()); var challengeResult = await PlayFab.PlayFabClientAPI.GetWindowsHelloChallengeAsync(new GetWindowsHelloChallengeRequest { PublicKeyHint = publicKeyHint, TitleId = PlayFab.PlayFabSettings.TitleId }); if (challengeResult.Error != null) { // TODO: Failed to get a challenge, handle the error MessageDialog message = new MessageDialog($"Error during getting challenge: {challengeResult.Error.Error}"); await message.ShowAsync(); return(false); } // Sign the challenge using the user's KeyCredential. IBuffer challengeBuffer = CryptographicBuffer.DecodeFromBase64String(challengeResult.Result.Challenge); KeyCredentialOperationResult opResult = await userCredential.RequestSignAsync(challengeBuffer); if (opResult.Status != KeyCredentialStatus.Success) { MessageDialog message = new MessageDialog("Failed to have user sign the challenge string."); await message.ShowAsync(); return(false); } // Get the signature. IBuffer signatureBuffer = opResult.Result; // Send the signature back to the server to confirm our identity. // The publicKeyHint tells the server which public key to use to verify the signature. var loginResult = await PlayFab.PlayFabClientAPI.LoginWithWindowsHelloAsync(new LoginWithWindowsHelloRequest { ChallengeSignature = CryptographicBuffer.EncodeToBase64String(signatureBuffer), PublicKeyHint = publicKeyHint }); if (loginResult.Error != null) { MessageDialog message = new MessageDialog($"Error during login: {loginResult.Error.Error}"); await message.ShowAsync(); return(false); } return(true); }
public IBuffer GetNonce() { return(CryptographicBuffer.DecodeFromBase64String(Nonce)); }
/// <summary> /// Generates an encryption key derived using a password, a random salt, and specified number of rounds of PBKDF2 /// /// TODO: pass in password via SecureString? /// </summary> /// <param name="password"></param> /// <param name="salt"></param> /// <returns></returns> public static IBuffer GetEncryptionKey(string password, string salt) { if (string.IsNullOrEmpty(password)) { throw new ArgumentException("Password is empty"); } if (salt == null || salt.Length == 0) { throw new ArgumentException("Salt is empty"); } KeyDerivationAlgorithmProvider pbkdf2 = KeyDerivationAlgorithmProvider.OpenAlgorithm(KeyDerivationAlgorithmNames.Pbkdf2Sha1); IBuffer buffSecret = CryptographicBuffer.ConvertStringToBinary(password, BinaryStringEncoding.Utf8); CryptographicKey key = pbkdf2.CreateKey(buffSecret); KeyDerivationParameters parameters = KeyDerivationParameters.BuildForPbkdf2(CryptographicBuffer.DecodeFromBase64String(salt), PBKDF2_ITERATIONS); return(CryptographicEngine.DeriveKeyMaterial(key, parameters, KEY_SIZE_BYTES)); }
public void TestIv() { IBuffer iv = CryptographicBuffer.DecodeFromBase64String(FileEncryptor.GetInitializationVector()); Assert.AreEqual(16U, iv.Length); }
private string DecryptChannelUri(string uri) { var channelBuffer = CryptographicBuffer.DecodeFromBase64String(uri); return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, channelBuffer)); }
public Salsa20RandomGeneratorTests() { _key = CryptographicBuffer.DecodeFromBase64String( "SU2mgYhg2SUHDlM/ReJv49vIYEY6dXVjz7EYlRPqh00="); }
/// <summary> /// Create a new note in the account of the user with the specified developer token. /// </summary> /// <returns>true if the note was created successfully, false otherwise.</returns> public bool createNote(String developerToken) { try { try { if (!auth(developerToken)) { // This is an unrecoverable error - our protocol version is out of date return(false); } } catch (EDAMUserException eux) { // TODO - do proper error handling return(false); } THttpClient noteStoreTransport = new THttpClient(new Uri(noteStoreUrl)); noteStoreTransport.CustomHeaders[HttpRequestHeader.UserAgent.ToString()] = USER_AGENT; TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport); NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol); // The bytes of the image we want to send up to the service // In this test, we use an image hardcoded as a base64-encoded string IBuffer imageBuffer = CryptographicBuffer.DecodeFromBase64String(imgBase64); byte[] imageBytes = WindowsRuntimeBufferExtensions.ToArray(imageBuffer); HashAlgorithmProvider provider = HashAlgorithmProvider.OpenAlgorithm("MD5"); IBuffer hashBuffer = provider.HashData(imageBuffer); byte[] hash = WindowsRuntimeBufferExtensions.ToArray(hashBuffer); String hashHex = CryptographicBuffer.EncodeToHexString(hashBuffer); Data data = new Data(); data.Size = imageBytes.Length; data.BodyHash = hash; data.Body = imageBytes; Resource resource = new Resource(); resource.Mime = "image/png"; resource.Data = data; Note note = new Note(); note.Title = "Hello, World!"; note.Content = EDAM_NOTE_PREAMBLE + "<h2>This note is created by the Evernote sample code for Windows Store applications!</h2>" + "<br />" + "<en-media type=\"image/png\" hash=\"" + hashHex + "\"/>" + EDAM_NOTE_POSTAMBLE; note.Resources = new List <Resource>(); note.Resources.Add(resource); try { noteStore.createNote(authToken, note); return(true); } catch (EDAMUserException ex) { // Handle note creation failure } } catch (TApplicationException tax) { // Handle generic Thrift error } catch (TTransportException ttx) { // Handle networking error } catch (EDAMSystemException esx) { // Handle unrecoverable Evernote error (i.e., error not caused by bad user input) } return(false); }
public string Decrypt(string toDecrypt, string key) { IBuffer toDecryptBuffer = CryptographicBuffer.DecodeFromBase64String(toDecrypt); return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, Decrypt(toDecryptBuffer, key))); }
/// <summary> /// This is the click handler for the 'RunSample' button. It is responsible for executing the sample code. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void RunSample_Click(object sender, RoutedEventArgs e) { IBuffer buffer; Scenario1Text.Text = ""; // Initialize example data. byte[] ByteArray = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; String base64String = "uiwyeroiugfyqcajkds897945234=="; String hexString = "30313233"; String inputString = "Input string"; // Generate random bytes. buffer = CryptographicBuffer.GenerateRandom(32); Scenario1Text.Text += "GenerateRandom\n"; Scenario1Text.Text += " Buffer: " + CryptographicBuffer.EncodeToHexString(buffer) + "\n\n"; // Convert from a byte array. buffer = CryptographicBuffer.CreateFromByteArray(ByteArray); Scenario1Text.Text += "CreateFromByteArray\n"; Scenario1Text.Text += " Buffer: " + CryptographicBuffer.EncodeToHexString(buffer) + "\n\n"; // Decode a Base64 encoded string to binary. buffer = CryptographicBuffer.DecodeFromBase64String(base64String); Scenario1Text.Text += "DecodeFromBase64String\n"; Scenario1Text.Text += " Base64 String: " + base64String + "\n"; Scenario1Text.Text += " Buffer: " + CryptographicBuffer.EncodeToHexString(buffer) + "\n\n"; // Decode a hexadecimal string to binary. buffer = CryptographicBuffer.DecodeFromHexString(hexString); Scenario1Text.Text += "DecodeFromHexString\n"; Scenario1Text.Text += " Hex String: " + hexString + "\n"; Scenario1Text.Text += " Buffer: " + CryptographicBuffer.EncodeToHexString(buffer) + "\n\n"; // Convert a string to UTF16BE binary data. buffer = CryptographicBuffer.ConvertStringToBinary(inputString, BinaryStringEncoding.Utf16BE); Scenario1Text.Text += "ConvertStringToBinary (Utf16BE)\n"; Scenario1Text.Text += " String: " + inputString + "\n"; Scenario1Text.Text += " Buffer: " + CryptographicBuffer.EncodeToHexString(buffer) + "\n\n"; // Convert a string to UTF16LE binary data. buffer = CryptographicBuffer.ConvertStringToBinary(inputString, BinaryStringEncoding.Utf16LE); Scenario1Text.Text += "ConvertStringToBinary (Utf16LE)\n"; Scenario1Text.Text += " String: " + inputString + "\n"; Scenario1Text.Text += " Buffer: " + CryptographicBuffer.EncodeToHexString(buffer) + "\n\n"; // Convert a string to UTF8 binary data. buffer = CryptographicBuffer.ConvertStringToBinary(inputString, BinaryStringEncoding.Utf8); Scenario1Text.Text += "ConvertStringToBinary (Utf8)\n"; Scenario1Text.Text += " String: " + inputString + "\n"; Scenario1Text.Text += " Buffer: " + CryptographicBuffer.EncodeToHexString(buffer) + "\n\n"; // Decode from a Base64 encoded string. buffer = CryptographicBuffer.DecodeFromBase64String(base64String); Scenario1Text.Text += "DecodeFromBase64String \n"; Scenario1Text.Text += " String: " + base64String + "\n"; Scenario1Text.Text += " Buffer (Hex): " + CryptographicBuffer.EncodeToHexString(buffer) + "\n\n"; Scenario1Text.Text += " Buffer (Base64): " + CryptographicBuffer.EncodeToBase64String(buffer) + "\n\n"; // Decode from a hexadecimal encoded string. buffer = CryptographicBuffer.DecodeFromHexString(hexString); Scenario1Text.Text += "DecodeFromHexString \n"; Scenario1Text.Text += " String: " + hexString + "\n"; Scenario1Text.Text += " Buffer: " + CryptographicBuffer.EncodeToHexString(buffer) + "\n\n"; }
private void StartResultReceivingThread() { IAsyncAction asyncAction = Windows.System.Threading.ThreadPool.RunAsync( async(workItem) => { while (true) { // receive current time at server string recvMsg = await receiveMsgAsync(_resultReceivingSocketReader); Debug.WriteLine(recvMsg); JsonObject obj = JsonValue.Parse(recvMsg).GetObject(); string status = null; string result = null; long frameID = -1; string engineID = null; try { status = obj.GetNamedString("status"); result = obj.GetNamedString("result"); frameID = (long)obj.GetNamedNumber("frame_id"); engineID = obj.GetNamedString("engine_id"); } catch (Exception) { Debug.WriteLine("the return message has no status field"); return; } ReceivedPacketInfo receivedPacketInfo = new ReceivedPacketInfo(frameID, engineID, status); receivedPacketInfo.setMsgRecvTime(GetTimeMillis()); if (!status.Equals("success")) { receivedPacketInfo.setGuidanceDoneTime(GetTimeMillis()); await _tokenController.ProcessReceivedPacket(receivedPacketInfo); continue; } if (result != null) { /* parsing result */ JsonObject resultJSON = JsonValue.Parse(result).GetObject(); // image guidance string imageFeedbackString = null; try { imageFeedbackString = resultJSON.GetNamedString("image"); } catch (Exception) { Debug.WriteLine("no image guidance found"); } if (imageFeedbackString != null) { IBuffer buffer = CryptographicBuffer.DecodeFromBase64String(imageFeedbackString); //byte[] imageFeedbackBytes; //CryptographicBuffer.CopyToByteArray(buffer, out imageFeedbackBytes); using (var stream = new InMemoryRandomAccessStream()) { using (var dataWriter = new DataWriter(stream)) { dataWriter.WriteBuffer(buffer); await dataWriter.StoreAsync(); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); SoftwareBitmap imageFeedback = await decoder.GetSoftwareBitmapAsync(); SoftwareBitmap imageFeedbackDisplay = SoftwareBitmap.Convert(imageFeedback, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied); await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { var sbSource = new SoftwareBitmapSource(); await sbSource.SetBitmapAsync(imageFeedbackDisplay); GuidanceImage.Source = sbSource; }); } } } // speech guidance string speechFeedback = null; try { speechFeedback = resultJSON.GetNamedString("speech"); } catch (Exception) { Debug.WriteLine("no speech guidance found"); } if (speechFeedback != null) { SpeechSynthesisStream stream = null; using (SpeechSynthesizer synthesizer = new SpeechSynthesizer()) { stream = await synthesizer.SynthesizeTextToStreamAsync(speechFeedback); } // Send the stream to the media object. await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { _mediaElement.SetSource(stream, stream.ContentType); _mediaElement.Play(); }); } receivedPacketInfo.setGuidanceDoneTime(GetTimeMillis()); await _tokenController.ProcessReceivedPacket(receivedPacketInfo); } } }); // A reference to the work item is cached so that we can trigger a // cancellation when the user presses the Cancel button. _resultReceivingWorkItem = asyncAction; }
public Rc4RandomGeneratorTests() { _key = CryptographicBuffer.DecodeFromBase64String( "SfJI2VqUv500zHC3qgkJF5yCTiVmGDdIVdLxcp2uPf8="); }
private static string Base64Decode(string value) { return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, CryptographicBuffer.DecodeFromBase64String(value))); }
public static string FromBase64(string str) { var buffer = CryptographicBuffer.DecodeFromBase64String(str); return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, buffer)); }
public void TestSalt() { IBuffer iv = CryptographicBuffer.DecodeFromBase64String(FileEncryptor.GetRandomSalt()); Assert.AreEqual(8U, iv.Length); }
/// <summary> /// Decode a string that has been base64 encoded /// </summary> /// <param name="data"></param> /// <returns></returns> public static string DecodeBase64(string data) { #if NETFX_CORE || (ENABLE_IL2CPP && UNITY_WSA_10_0) return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, CryptographicBuffer.DecodeFromBase64String(data))); #else return(string.Empty); #endif }
public static string DecodeFromBase64String(string value) { IBuffer buffer = CryptographicBuffer.DecodeFromBase64String(value); return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, buffer)); }
public string Decode(string encodedString) { var buffer = CryptographicBuffer.DecodeFromBase64String(encodedString); return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, buffer)); }