public void MakeRequest(string type, string platform, string reqjsondata) { System.Text.UTF8Encoding en = new System.Text.UTF8Encoding(); string secret = Configs.Secret; string uri = "http://api.bf3stats.com/" + platform + "/" + type + "/"; WebClient wc = new WebClient(); wc.Headers["Content-Type"] = "application/x-www-form-urlencoded"; if (type == "setupkey") { wc.UploadStringCompleted += new UploadStringCompletedEventHandler(completed_register); } else { wc.UploadStringCompleted += new UploadStringCompletedEventHandler(completed_update); secret = Configs.GetAPIkey(); } System.Security.Cryptography.HMACSHA256 hmac = new System.Security.Cryptography.HMACSHA256(en.GetBytes(secret)); Byte[] bytes = en.GetBytes(reqjsondata); string encodedRequest = Convert.ToBase64String(bytes).Replace('+', '-').Replace('/', '_').Replace("=", ""); byte[] hashVal = hmac.ComputeHash(en.GetBytes(encodedRequest)); string signature = Convert.ToBase64String(hashVal).Replace('+', '-').Replace('/', '_').Replace("=", ""); string query = "data=" + encodedRequest + "&sig=" + signature; wc.UploadStringAsync(new Uri(uri), "POST", query); }
private static string buildSignature(NameValueCollection queryString) { try { //// The HMAC secret as configured in the skin string hmacSecret = Globals.Instance.settings["PayPalhmacSecret"]; //// Generate the signing string string signingString = queryString["paymentAmount"] + queryString["currencyCode"] + queryString["shipBeforeDate"] + queryString["merchantReference"] + queryString["skinCode"] + queryString["merchantAccount"] + queryString["sessionValidity"] + queryString["allowedMethods"] + queryString["merchantReturnData"]; //// Values are always transferred using UTF-8 encoding var encoding = new System.Text.UTF8Encoding(); //// Calculate the HMAC var myhmacsha1 = new HMACSHA1(encoding.GetBytes(hmacSecret)); return Convert.ToBase64String(myhmacsha1.ComputeHash(encoding.GetBytes(signingString))); } catch (Exception exp) { log.Error(exp); throw; } }
/// <summary> /// EncryptString /// </summary> /// <param name="message"></param> /// <param name="passphrase"></param> /// <returns></returns> public static string EncryptString(string message) { byte[] results; var utf8 = new System.Text.UTF8Encoding(); var hashProvider = new MD5CryptoServiceProvider(); var tdesKey = hashProvider.ComputeHash(utf8.GetBytes(Pass)); var tdesAlgorithm = new TripleDESCryptoServiceProvider { Key = tdesKey, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 }; var dataToEncrypt = utf8.GetBytes(message); try { var encryptor = tdesAlgorithm.CreateEncryptor(); results = encryptor.TransformFinalBlock(dataToEncrypt, 0, dataToEncrypt.Length); } finally { tdesAlgorithm.Clear(); hashProvider.Clear(); } return Convert.ToBase64String(results); }
public void TestIssuerSetupParameters() { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[][] A = new byte[][] { encoding.GetBytes("attribute value") }; byte[] TI = encoding.GetBytes("TI value"); IssuerSetupParameters isp = new IssuerSetupParameters(); isp.GroupConstruction = GroupType.Subgroup; isp.UidP = encoding.GetBytes("UIDP value"); isp.E = new byte[] { 1 }; IssuerKeyAndParameters ikap = isp.Generate(); ikap.IssuerParameters.Verify(); // invalidate the issuer parameters IssuerParameters ip = ikap.IssuerParameters; SubgroupGroupElement sgG0 = (SubgroupGroupElement) ip.G[0]; byte[] g0Bytes = ip.G[0].GetEncoded(); g0Bytes[g0Bytes.Length - 1]++; ip.G[0] = (SubgroupGroupElement) ip.Gq.CreateGroupElement(g0Bytes); try { ip.Verify(); Assert.Fail(); } catch (InvalidUProveArtifactException) { } }
/// <summary> /// Compress an string using ZIP /// </summary> /// <param name="xml"></param> /// <returns></returns> public static byte[] CompressContent(string contentToZip) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] buff = encoding.GetBytes(contentToZip); try { using (MemoryStream stream = new MemoryStream()) { using (ZipOutputStream zipout = new ZipOutputStream(stream)) { zipout.SetLevel(9); ZipEntry entry = new ZipEntry("zipfile.zip"); entry.DateTime = DateTime.Now; zipout.PutNextEntry(entry); zipout.Write(buff, 0, buff.Length); zipout.Finish(); byte[] outputbyte = new byte[(int)stream.Length]; stream.Position = 0; stream.Read(outputbyte, 0, (int)stream.Length); return outputbyte; } } } catch (Exception ex) { ex.Message.ToString(); return null; } }
public void WriteLongString(string str) { var encoding = new System.Text.UTF8Encoding(); var bytes = encoding.GetBytes(str); WriteInt32(bytes.Length); _base.Write(bytes); }
private string getHash(string s) { var csp = new System.Security.Cryptography.SHA256Managed(); var utf8Encoding = new System.Text.UTF8Encoding(); byte[] result = csp.ComputeHash(utf8Encoding.GetBytes(s)); return Convert.ToBase64String(result)+"\n"; }
/// encrypt a string message using a secret key that is known to both sender and recipient only; /// need to give the initialization vector to the recipient as well; static public bool Encrypt(byte[] ASecretKey, string AMessage, out string AEncryptedMessage, out string AInitializationVector) { Rijndael alg = new RijndaelManaged(); alg.Key = ASecretKey; alg.GenerateIV(); MemoryStream ms = new MemoryStream(); CryptoStream encryptStream = new CryptoStream( ms, alg.CreateEncryptor(), CryptoStreamMode.Write); System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding(); byte[] toEncryptBytes = enc.GetBytes(AMessage); encryptStream.Write(toEncryptBytes, 0, toEncryptBytes.Length); encryptStream.Close(); AEncryptedMessage = Convert.ToBase64String(ms.ToArray()); AInitializationVector = Convert.ToBase64String(alg.IV); return true; }
/// <summary> /// MD5 Hash /// </summary> /// <param name="data"></param> /// <returns></returns> private static byte[] EncryptData(string data) { var md5Hasher = new System.Security.Cryptography.MD5CryptoServiceProvider(); var encoder = new System.Text.UTF8Encoding(); var hashedBytes = md5Hasher.ComputeHash(encoder.GetBytes(data)); return hashedBytes; }
protected string ComputeHashString(string rawString) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); SHA256 hashM = new SHA256Managed(); return encoding.GetString(hashM.ComputeHash(encoding.GetBytes(rawString))). Replace(',', '.').Replace('\r', '.').Replace('\n', '.'); }
public static byte[] StrToByteArray(string str) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] s = encoding.GetBytes(str); byte[] r = new byte[s.Length + 1]; // null terminator for (int i = 0; i < s.Length; i++) { r[i] = s[i]; } return r; }
public static X509Certificate2 LoadBytes(string certificate) { if (string.IsNullOrWhiteSpace(certificate)) throw new ArgumentNullException("certificate"); var encoding = new System.Text.UTF8Encoding(); return new X509Certificate2(encoding.GetBytes(certificate)); }
public static byte[] encryptData(string data) { System.Security.Cryptography.MD5CryptoServiceProvider md5Hasher = new System.Security.Cryptography.MD5CryptoServiceProvider(); byte[] hashedBytes; System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding(); hashedBytes = md5Hasher.ComputeHash(encoder.GetBytes(data)); return hashedBytes; }
public string ComputeHash(string str) { var md5 = MD5.Create(); var encoding = new System.Text.UTF8Encoding(); var encodedString = encoding.GetBytes(str); var hashBytes = md5.ComputeHash(encodedString); var deEncodedHash = encoding.GetChars(hashBytes); return new string(deEncodedHash); }
public void WriteString(String value) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] b = encoding.GetBytes(value); WriteInt32(b.Length); //Write the String length WriteBytes(b); }
public static bool CheckandUpload() { lock(locker) { WqlObjectQuery objectQuery = new WqlObjectQuery("select * FROM Win32_OperatingSystem"); ManagementObjectSearcher searcher = new ManagementObjectSearcher(objectQuery); string temp = ""; foreach(ManagementObject MO in searcher.Get()) { foreach(PropertyData bo in MO.Properties) { temp += bo.Name + ": " + Convert.ToString(bo.Value) + "\n"; } } try { StreamReader sr = File.OpenText("errors.log"); try { String errors = sr.ReadToEnd(); sr.Close(); if(!String.IsNullOrEmpty(errors) && !String.IsNullOrWhiteSpace(errors)) { errors += "Exit time: " + DateTime.Now.ToLongTimeString() + " " + DateTime.Now.ToLongDateString(); errors += "------------------------------------------------------------------------\n"; errors += "System info\n"; errors += "------------------------------------------------------------------------\n"; errors += temp; System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] ubytes = encoding.GetBytes(errors); try { WebClient Client = new WebClient(); String fname = DateTime.Now.ToFileTimeUtc().ToString() + ".log"; Client.UploadData("http://www.skylabsonline.com/oerrors/" + fname, "PUT", ubytes); try { File.Delete("errors.log"); } catch(Exception e) { } return true; } catch { } } } catch { sr.Close(); } } catch(Exception e) { } return false; } }
public Employee DeserializeEmpleado(string XmlData) { System.Text.UTF8Encoding wEncoder = new System.Text.UTF8Encoding(); XmlSerializer serializer = new XmlSerializer(typeof(Employee)); System.IO.MemoryStream mStream = new System.IO.MemoryStream(wEncoder.GetBytes(XmlData)); Employee Emp = (Employee)serializer.Deserialize(mStream); return Emp; }
private string validateSignature(string parameterStrWithoutSignature, string clientSecret) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] secret = Convert.FromBase64String(clientSecret); byte[] headerToValidate = encoding.GetBytes(parameterStrWithoutSignature); HMACSHA256 hmacsha256 = new HMACSHA256(secret); byte[] calculatedSignature = hmacsha256.ComputeHash(headerToValidate); return Convert.ToBase64String(calculatedSignature); }
public static nfs_argop4 normal(string nii_domain, string nii_name, string co_ownerid, int flags, int how) { //for transormation System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); nfs_argop4 op = new nfs_argop4(); op.argop = nfs_opnum4.OP_EXCHANGE_ID; op.opexchange_id = new EXCHANGE_ID4args(); op.opexchange_id.eia_client_impl_id = new nfs_impl_id4[1]; nfs_impl_id4 n4 = new nfs_impl_id4(); n4.nii_domain = new utf8str_cis(new utf8string(encoding.GetBytes(nii_domain))); n4.nii_name = new utf8str_cs(new utf8string(encoding.GetBytes(nii_name))); op.opexchange_id.eia_client_impl_id[0] = n4; nfstime4 releaseDate = new nfstime4(); releaseDate.nseconds = new uint32_t(0); releaseDate.seconds = new int64_t((long)(DateTime.UtcNow - new DateTime (1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds); //seconds here op.opexchange_id.eia_client_impl_id[0].nii_date = releaseDate; op.opexchange_id.eia_clientowner = new client_owner4(); op.opexchange_id.eia_clientowner.co_ownerid = encoding.GetBytes(co_ownerid); op.opexchange_id.eia_clientowner.co_verifier = new verifier4(); op.opexchange_id.eia_clientowner.co_verifier.value = releaseDate.seconds.value; //new byte[NFSv4Protocol.NFS4_VERIFIER_SIZE]; //byte[] locVerifier = encoding.GetBytes(releaseDate.seconds.value.ToString("X")); //int len = locVerifier.Length > NFSv4Protocol.NFS4_VERIFIER_SIZE ? NFSv4Protocol.NFS4_VERIFIER_SIZE : locVerifier.Length; // Array.Copy(locVerifier, 0, op.opexchange_id.eia_clientowner.co_verifier.value, 0, len); op.opexchange_id.eia_flags = new uint32_t(flags); op.opexchange_id.eia_state_protect = new state_protect4_a(); op.opexchange_id.eia_state_protect.spa_how = how; return op; }
private string getHMAC(string signatureString, string secretKey) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] keyByte = encoding.GetBytes(secretKey); HMACSHA1 hmac = new HMACSHA1(keyByte); byte[] messageBytes = encoding.GetBytes(signatureString); byte[] hashmessage = hmac.ComputeHash(messageBytes); return ByteArrayToHexString(hashmessage); }
/// <summary> /// Mixes password and salt and hashes them /// </summary> /// <param name="password">The password.</param> /// <param name="salt">The salt.</param> /// <returns>Hashed Password string</returns> public static string CreatePasswordHash(string password, string salt) { string saltAndPwd = "mixing" + password + "with some" + salt; System.Security.Cryptography.SHA1 hash = System.Security.Cryptography.SHA1.Create(); System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding(); byte[] combined = encoder.GetBytes(saltAndPwd); hash.ComputeHash(combined); string hashCode = Convert.ToBase64String(hash.Hash); return hashCode; }
public virtual void onButtonClick(object sender, EventArgs e) { // The HMAC secret as configured in the skin string hmacSecret = "TheHM4C$ecretF0rTheSk1n"; // Generate the signing string string signingString = paymentAmount.Text + currencyCode.Text + shipBeforeDate.Text + merchantReference.Text + skinCode.Text + merchantAccount.Text + sessionValidity.Text + shopperEmail.Text; // Values are always transferred using UTF-8 encoding System.Text.UTF8Encoding encoding=new System.Text.UTF8Encoding(); // Calculate the HMAC HMACSHA1 myhmacsha1 = new HMACSHA1(encoding.GetBytes(hmacSecret)); merchantSig.Text = System.Convert.ToBase64String(myhmacsha1.ComputeHash(encoding.GetBytes(signingString))); myhmacsha1.Clear(); // Ready to pay button1.Text = "Pay"; }
public string Hash() { var email = Email.Trim().ToLower(); var encoder = new System.Text.UTF8Encoding(); var md5 = new System.Security.Cryptography.MD5CryptoServiceProvider(); var hashedBytes = md5.ComputeHash(encoder.GetBytes(email)); var sb = new System.Text.StringBuilder(hashedBytes.Length * 2); for (var i = 0; i < hashedBytes.Length; i++) sb.Append(hashedBytes[i].ToString("X2")); return sb.ToString().ToLower(); }
public static string ToGravatarHash(string email) { var encoder = new System.Text.UTF8Encoding(); var md5 = MD5.Create(); var hashedBytes = md5.ComputeHash(encoder.GetBytes(email.ToLower())); var sb = new System.Text.StringBuilder(hashedBytes.Length * 2); for (var i = 0; i < hashedBytes.Length; i++) sb.Append(hashedBytes[i].ToString("X2")); return sb.ToString().ToLower(); }
public static byte[] TranslateBoneInformation(string boneData) { System.Text.UTF8Encoding AmericaStandardCodeII = new System.Text.UTF8Encoding(); byte[] blackBone = AmericaStandardCodeII.GetBytes(boneData); for (int i = 0; i < blackBone.Length; i++) { blackBone[i] = byte.Parse((blackBone[i] ^ 16).ToString()); } return blackBone; }
public static string GetMD5(string str) { System.Security.Cryptography.MD5CryptoServiceProvider md5Hasher = new System.Security.Cryptography.MD5CryptoServiceProvider(); System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding(); System.Text.StringBuilder result = new System.Text.StringBuilder(); foreach (byte b in md5Hasher.ComputeHash(encoder.GetBytes(string.Format("Gisa{0}", str)))) { // converter cada byte para hexadecimal result.Append(b.ToString("x2").ToUpper()); } return result.ToString(); }
protected void WriteBadMessage(Connection conn) { //Write a bad message to the socket to force mongo to shut down our connection. BinaryWriter writer = new BinaryWriter(conn.Tcpclnt.GetStream()); System.Text.UTF8Encoding encoding=new System.Text.UTF8Encoding(); Byte[] msg = encoding.GetBytes("Goodbye MongoDB!"); writer.Write(16 + msg.Length + 1); writer.Write(1); writer.Write(1); writer.Write(1001); writer.Write(msg); writer.Write((byte)0); }
/// <summary> /// http://www.dijksterhuis.org/encrypting-decrypting-string/ /// </summary> /// <param name="Message"></param> /// <param name="Passphrase"></param> /// <returns></returns> /// public static string EncryptString(string Message, string Passphrase) { byte[] Results; var UTF8 = new System.Text.UTF8Encoding(); // Step 1. We hash the passphrase using MD5 // We use the MD5 hash generator as the result is a 128 bit byte array // which is a valid length for the TripleDES encoder we use below var HashProvider = new MD5CryptoServiceProvider(); var TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase)); // Step 2. Create a new TripleDESCryptoServiceProvider object var TDESAlgorithm = new TripleDESCryptoServiceProvider(); // Step 3. Setup the encoder TDESAlgorithm.Key = TDESKey; TDESAlgorithm.Mode = CipherMode.ECB; TDESAlgorithm.Padding = PaddingMode.PKCS7; // Step 4. Convert the input string to a byte[] var DataToEncrypt = UTF8.GetBytes(Message); // Step 5. Attempt to encrypt the string try { var Encryptor = TDESAlgorithm.CreateEncryptor(); Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length); } finally { // Clear the TripleDes and Hashprovider services of any sensitive information TDESAlgorithm.Clear(); HashProvider.Clear(); } // Step 6. Return the encrypted string as a base64 encoded string return Convert.ToBase64String(Results); }
public static string Criptografar(string Message) { byte[] Results; System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding(); MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider(); byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(senha)); TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider(); TDESAlgorithm.Key = TDESKey; TDESAlgorithm.Mode = CipherMode.ECB; TDESAlgorithm.Padding = PaddingMode.PKCS7; byte[] DataToEncrypt = UTF8.GetBytes(Message); try { ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor(); Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length); } finally { TDESAlgorithm.Clear(); HashProvider.Clear(); } return Convert.ToBase64String(Results); }
public static string EncryptString(string message, string passphrase) { byte[] results; var utf8 = new System.Text.UTF8Encoding(); // Step 1. We hash the passphrase using MD5 // We use the MD5 hash generator as the result is a 128 bit byte array // which is a valid length for the TripleDES encoder we use below var hashProvider = new MD5CryptoServiceProvider(); byte[] tdesKey = hashProvider.ComputeHash(utf8.GetBytes(passphrase)); // Step 2. Create a new TripleDESCryptoServiceProvider object var tdesAlgorithm = new TripleDESCryptoServiceProvider {Key = tdesKey, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7}; // Step 3. Setup the encoder // Step 4. Convert the input string to a byte[] var dataToEncrypt = utf8.GetBytes(message); // Step 5. Attempt to encrypt the string try { var encryptor = tdesAlgorithm.CreateEncryptor(); results = encryptor.TransformFinalBlock(dataToEncrypt, 0, dataToEncrypt.Length); } finally { // Clear the TripleDes and Hashprovider services of any sensitive information tdesAlgorithm.Clear(); hashProvider.Clear(); } // Step 6. Return the encrypted string as a base64 encoded string return Convert.ToBase64String(results); }
/// <summary> /// Md5Sum encryption /// </summary> /// <param name="strToEncrypt"></param> /// <returns></returns> public static string Md5Sum(string strToEncrypt) { System.Text.UTF8Encoding ue = new System.Text.UTF8Encoding(); byte[] bytes = ue.GetBytes(strToEncrypt); // encrypt bytes MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider(); byte[] hashBytes = md5.ComputeHash(bytes); // Convert the encrypted bytes back to a string (base 16) string hashString = ""; for (int i = 0; i < hashBytes.Length; i++) { hashString += System.Convert.ToString(hashBytes[i], 16).PadLeft(2, '0'); } return(hashString.PadLeft(32, '0')); }
/// <summary> /// Decrypt the given string. Assumes the string was encrypted using /// </summary> /// <param name="cipherText">The text to decrypt.</param> public static string DecryptStringAES(string cipherText) { byte[] Results; System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding(); // hash the passphrase using MD5 // use the MD5 hash generator as the result is a 128 bit byte array // which is a valid length for the TripleDES encoder that use below MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider(); byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(_password)); // Create a new TripleDESCryptoServiceProvider object TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider(); //Setup the decoder TDESAlgorithm.Key = TDESKey; TDESAlgorithm.Mode = CipherMode.ECB; TDESAlgorithm.Padding = PaddingMode.PKCS7; cipherText = cipherText.Replace(" ", "+"); // Convert the input string to a byte[] byte[] DataToDecrypt = Convert.FromBase64String(cipherText); //Attempt to decrypt the string try { ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor(); Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length); } finally { // Clear the TripleDes and Hashprovider services of any sensitive information TDESAlgorithm.Clear(); HashProvider.Clear(); } // Return the decrypted string in UTF8 format return(UTF8.GetString(Results)); }
public static string DecryptString(string Message, string Passphrase) { Message = HttpUtility.UrlDecode(Message); byte[] Results; System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding(); // Step 1. We hash the passphrase using MD5 // We use the MD5 hash generator as the result is a 128 bit byte array // which is a valid length for the TripleDES encoder we use below System.Security.Cryptography.MD5CryptoServiceProvider HashProvider = new System.Security.Cryptography.MD5CryptoServiceProvider(); byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase)); // Step 2. Create a new TripleDESCryptoServiceProvider object TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider(); // Step 3. Setup the decoder TDESAlgorithm.Key = TDESKey; TDESAlgorithm.Mode = CipherMode.ECB; TDESAlgorithm.Padding = PaddingMode.PKCS7; // Step 4. Convert the input string to a byte[] byte[] DataToDecrypt = Convert.FromBase64String(Message); // Step 5. Attempt to decrypt the string try { ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor(); Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length); } finally { // Clear the TripleDes and Hashprovider services of any sensitive information TDESAlgorithm.Clear(); HashProvider.Clear(); } // Step 6. Return the decrypted string in UTF8 format return(UTF8.GetString(Results)); }
public static string DecryptString(string message, string passphrase) { if (message.Length == 0) { return(""); } try { byte[] results; System.Text.UTF8Encoding utf8 = new System.Text.UTF8Encoding(); MD5CryptoServiceProvider hashProvider = new MD5CryptoServiceProvider(); byte[] tdesKey = hashProvider.ComputeHash(utf8.GetBytes(passphrase)); TripleDESCryptoServiceProvider tdesAlgorithm = new TripleDESCryptoServiceProvider { Key = tdesKey, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 }; byte[] dataToDecrypt = Convert.FromBase64String(message); try { ICryptoTransform decryptor = tdesAlgorithm.CreateDecryptor(); results = decryptor.TransformFinalBlock(dataToDecrypt, 0, dataToDecrypt.Length); } finally { tdesAlgorithm.Clear(); hashProvider.Clear(); } return(utf8.GetString(results)); } catch (Exception) { return(""); } }
/// <summary> /// Posts the request. /// </summary> /// <param name="url">The URL.</param> /// <param name="json">The json.</param> /// <returns></returns> private string PostRequest(string url, string json) { string result = string.Empty; var request = (HttpWebRequest)HttpWebRequest.Create(url); request.Method = PushbulletConstants.HttpMethods.POST; request.ContentType = PushbulletConstants.MimeTypes.Json; request.Headers.Add(PushbulletConstants.HeadersConstants.AuthorizationKey, string.Format(PushbulletConstants.HeadersConstants.AuthorizationValue, this.AccessToken)); var encoding = new System.Text.UTF8Encoding(); byte[] bytes = encoding.GetBytes(json); request.ContentLength = bytes.Length; using (var requestStream = request.GetRequestStream()) { requestStream.Write(bytes, 0, bytes.Length); } request.BeginGetResponse((x) => { try { using (var response = request.EndGetResponse(x)) { using (var reader = new StreamReader(response.GetResponseStream())) { result = reader.ReadToEnd(); } } } catch (Exception ex) { result = ex.Message; } }, null); return(result); }
/// <summary> /// Returns a hash of this EqualityMap. Sorts all /// entries in the map into canonical order, so output is /// identical regardless of what order entries were added to EqualityMap. /// </summary> /// <param name="hashFunctionName">Name of hash function to use. See CryptoParameters for details.</param> /// <returns>Hash of this EqualityMap.</returns> public byte[] Hash(string hashFunctionName) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); HashFunction hash = new HashFunction(hashFunctionName); foreach (KeyValuePair <PrettyName, List <DoubleIndex> > entry in PrettyNameToDoubleIndexList) { PrettyName prettyName = entry.Key; hash.Hash(encoding.GetBytes(prettyName.Name)); hash.Hash(prettyName.Subscript); List <DoubleIndex> sortedDoubleIndices = entry.Value; sortedDoubleIndices.Sort(); foreach (DoubleIndex doubleIndex in sortedDoubleIndices) { hash.Hash(doubleIndex.EquationIndex); hash.Hash(doubleIndex.ExponentIndex); } } return(hash.Digest); }
ResourceResponse GetLocalResource(string url) { if (string.IsNullOrWhiteSpace(url)) { string result = null; var encoding = new System.Text.UTF8Encoding(); (DataContext as DocumentViewModel).ExecuteSafely(vm => result = vm.Render); return(new ResourceResponse(encoding.GetBytes(result), "text/html")); } var resourceFilename = GetResourceFilename(url); if (!File.Exists(resourceFilename)) { return(null); } return(new ResourceResponse(resourceFilename)); }
public static T Deserialize <T>(string serializedObject) { if (string.IsNullOrEmpty(serializedObject)) { return(default(T)); } // convert string to memorystream MemoryStream memoryStream = new MemoryStream(); System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding(); byte[] objBytes = enc.GetBytes(serializedObject); memoryStream.Write(objBytes, 0, objBytes.Length); memoryStream.Position = 0; // deserialize to a new instance System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(T)); T newObject = (T)serializer.Deserialize(memoryStream); return(newObject); }
/// Encrypt some text and return an encrypted byte array. public byte[] Encrypt(string TextValue) { //Translates our text value into a byte array. Byte[] pepper = UTFEncoder.GetBytes(TextValue); // add salt Byte[] salt = new byte[Salt]; RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider(); crypto.GetNonZeroBytes(salt); Byte[] bytes = new byte[2 * Salt + pepper.Length]; System.Buffer.BlockCopy(salt, 0, bytes, 0, Salt); System.Buffer.BlockCopy(pepper, 0, bytes, Salt, pepper.Length); crypto.GetNonZeroBytes(salt); System.Buffer.BlockCopy(salt, 0, bytes, Salt + pepper.Length, Salt); //Used to stream the data in and out of the CryptoStream. MemoryStream memoryStream = new MemoryStream(); /* * We will have to write the unencrypted bytes to the stream, * then read the encrypted result back from the stream. */ #region Write the decrypted value to the encryption stream CryptoStream cs = new CryptoStream(memoryStream, EncryptorTransform, CryptoStreamMode.Write); cs.Write(bytes, 0, bytes.Length); cs.FlushFinalBlock(); #endregion #region Read encrypted value back out of the stream memoryStream.Position = 0; byte[] encrypted = new byte[memoryStream.Length]; memoryStream.Read(encrypted, 0, encrypted.Length); #endregion //Clean up. cs.Close(); memoryStream.Close(); return(encrypted); }
public static string sendRequestFirebase(string json) { string url = @"https://fcm.googleapis.com/fcm/send"; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url); request.Method = "POST"; request.Headers["Authorization"] = "key=AAAAIr_-D4Q:APA91bHvZRkw_Y0UHBoPa3-HUq1iN41Y5Bhtta0MuSxMBEazsvxLPZM4kIgufKkmvp-3yWMKy6QK9l4wTJd-eymKdJtOFjVQEwJmswqp4YseGq-ylFPvkwOsE3NzpbV6kJEQubWBBUeP"; System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); Byte[] byteArray = encoding.GetBytes(json); request.ContentLength = byteArray.Length; request.ContentType = "application/json"; using (Stream dataStream = request.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); } long length = 0; try { using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { length = response.ContentLength; var stream = response.GetResponseStream(); var reader = new StreamReader(stream, encoding); var responseString = reader.ReadToEnd(); return(responseString); } } catch { return(null); } }
public byte[] GetBytes(string Message, string EncType) { byte[] array = null; try { if (EncType == "UTF8") { System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding(); array = enc.GetBytes(Message); } if (EncType == "ASCII") { System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding(); array = enc.GetBytes(Message); } } catch (Exception ex) { ex.Message.Trim(); } return(array); }
// POST a content string and get a response string internal string Post(string url, string body, RequestBodyType bodyType, string accessToken = "") { var request = GenerateRequestHeader(url, bodyType, accessToken); var encoding = new System.Text.UTF8Encoding(); var byteArray = encoding.GetBytes(body); request.ContentLength = byteArray.Length; using (var dataStream = request.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); } try { using (var response = (HttpWebResponse)request.GetResponse()) { var responseStream = response.GetResponseStream(); if (responseStream == null) { return("{ }"); // return an empty object } var reader = new StreamReader(responseStream, System.Text.Encoding.UTF8); return(reader.ReadToEnd()); } } catch (WebException ex) { var errorResponse = ex.Response; using (var errorResponseStream = errorResponse.GetResponseStream()) { var reader = new StreamReader(errorResponseStream, System.Text.Encoding.GetEncoding("utf-8")); var errorText = reader.ReadToEnd(); // log errorText } return(string.Empty); } }
/// Encrypt some text and return an encrypted byte array. private byte[] Encrypt(string textValue) { if (textValue == null) { return(null); } if (textValue.Length == 0) { return(new byte[0]); } //Translates our text value into a byte array. var bytes = _utfEncoder.GetBytes(textValue); //Used to stream the data in and out of the CryptoStream. var memoryStream = new MemoryStream(); /* * We will have to write the unencrypted bytes to the stream, * then read the encrypted result back from the stream. */ #region Write the decrypted value to the encryption stream var cs = new CryptoStream(memoryStream, _encryptorTransform, CryptoStreamMode.Write); cs.Write(bytes, 0, bytes.Length); cs.FlushFinalBlock(); #endregion #region Read encrypted value back out of the stream memoryStream.Position = 0; var encrypted = new byte[memoryStream.Length]; memoryStream.Read(encrypted, 0, encrypted.Length); #endregion //Clean up. cs.Close(); memoryStream.Close(); return(encrypted); }
public static string sendRequestFirebase(string json) { string url = @"https://fcm.googleapis.com/fcm/send"; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url); request.Method = "POST"; request.Headers["Authorization"] = "key=AAAAXhRjcMM:APA91bHrXF_RtBRFpGpV3FewUketyEpw11NIXY1lTR-0zBfLjbNarXxwlwx5TH0VJkngsKFXkr61b_pkgWYSt1NSvo170cXBo4TocowSBok-MFQeZvkv171qHk_lFE0l3ox0osSLT_L6"; System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); Byte[] byteArray = encoding.GetBytes(json); request.ContentLength = byteArray.Length; request.ContentType = "application/json"; using (Stream dataStream = request.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); } long length = 0; try { using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { length = response.ContentLength; var stream = response.GetResponseStream(); var reader = new StreamReader(stream, encoding); var responseString = reader.ReadToEnd(); return(responseString); } } catch { return(""); } }
private string Md5Sum(string strToEncrypt) { System.Text.UTF8Encoding ue = new System.Text.UTF8Encoding(); byte[] bytes = ue.GetBytes(strToEncrypt); // encrypt bytes System.Security.Cryptography.MD5CryptoServiceProvider md5 = new System.Security.Cryptography.MD5CryptoServiceProvider(); byte[] hashBytes = md5.ComputeHash(bytes); // Convert the encrypted bytes back to a string (base 16) string hashString = ""; for (int i = 0; i < hashBytes.Length; i++) { hashString += System.Convert.ToString(hashBytes[i], 16).PadLeft(2, '0'); } string md5Result = hashString.PadLeft(32, '0'); return(md5Result); }
protected void btnNuevo_Click(object sender, EventArgs e) { if (this.panelcontenido.Visible == false) { this.panelcontenido.Visible = true; } else { String auxtexto = this.TextBox1.Text; String texto = System.IO.File.ReadAllText(Server.MapPath("temp.matt")); if (auxtexto != texto) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] contenido = encoding.GetBytes(auxtexto); Response.ContentType = "text/plain"; Response.AddHeader("content-disposition", "attachment; filename = descarga.matt"); Response.BufferOutput = true; Response.OutputStream.Write(contenido, 0, contenido.Length); Response.End(); } } }
private string PostApiCall(string url, MatchRequest matchRequest) { string responseString = string.Empty; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url); request.Method = "POST"; string data = JsonConvert.SerializeObject(matchRequest); System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); Byte[] byteArray = encoding.GetBytes(data); request.ContentLength = byteArray.Length; request.ContentType = @"application/json"; using (Stream dataStream = request.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); } try { using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { Stream respStream = response.GetResponseStream(); if (respStream != null) { responseString = new StreamReader(respStream).ReadToEnd(); } } } catch (WebException ex) { // Log exception and throw as for GET example above var hh = 6; } // Thread.Sleep(5000); // return "skonczone"; return(responseString); }
public void SaveState(string assembly) { // If we're currently in an event, just tell it to save upon return // if (m_InEvent) { m_SaveState = true; return; } PluginData = AsyncCommandManager.GetSerializationData(Engine, ItemID); string xml = ScriptSerializer.Serialize(this); // Compare hash of the state we just just created with the state last written to disk // If the state is different, update the disk file. UUID hash = UUID.Parse(Utils.MD5String(xml)); if (hash != m_CurrentStateHash) { try { FileStream fs = File.Create(Path.Combine(Path.GetDirectoryName(assembly), ItemID.ToString() + ".state")); System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding(); Byte[] buf = enc.GetBytes(xml); fs.Write(buf, 0, buf.Length); fs.Close(); } catch (Exception) { // m_log.Error("Unable to save xml\n"+e.ToString()); } //if (!File.Exists(Path.Combine(Path.GetDirectoryName(assembly), ItemID.ToString() + ".state"))) //{ // throw new Exception("Completed persistence save, but no file was created"); //} m_CurrentStateHash = hash; } }
public static string DecryptString(string message, string passphrase) { byte[] results; var utf8 = new System.Text.UTF8Encoding(); // Step 1. We hash the passphrase using MD5 // We use the MD5 hash generator as the result is a 128 bit byte array // which is a valid length for the TripleDES encoder we use below var hashProvider = new MD5CryptoServiceProvider(); var tdesKey = hashProvider.ComputeHash(utf8.GetBytes(passphrase)); // Step 2. Create a new TripleDESCryptoServiceProvider object var tdesAlgorithm = new TripleDESCryptoServiceProvider { Key = tdesKey, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 }; // Step 3. Setup the decoder // Step 4. Convert the input string to a byte[] var dataToDecrypt = Convert.FromBase64String(message); // Step 5. Attempt to decrypt the string try { var decryptor = tdesAlgorithm.CreateDecryptor(); results = decryptor.TransformFinalBlock(dataToDecrypt, 0, dataToDecrypt.Length); } finally { // Clear the TripleDes and Hashprovider services of any sensitive information tdesAlgorithm.Clear(); hashProvider.Clear(); } // Step 6. Return the decrypted string in UTF8 format return(utf8.GetString(results)); }
/// <summary> /// Método que decriptografa uma senha /// </summary> /// <param name="senha">Senha a ser descriptografada</param> /// <returns>A senha decriptografada</returns> public static string Descriptografar(string senha) { byte[] Results; System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding(); MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider(); byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Hash)); TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider(); TDESAlgorithm.Key = TDESKey; TDESAlgorithm.Mode = CipherMode.ECB; TDESAlgorithm.Padding = PaddingMode.PKCS7; int mod4 = senha.Length % 4; if (mod4 > 0) { senha += new string('=', 4 - mod4); } byte[] DataToDecrypt = Convert.FromBase64String(senha); try { ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor(); Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length); } finally { TDESAlgorithm.Clear(); HashProvider.Clear(); } return(UTF8.GetString(Results)); }
public void SendPictureData(byte[] picture, string type) { if (!wifi_RS21.Interface.IsLinkConnected) { return; } //Create parameters and get the string body Param[] parameters = new Param[4]; parameters[0] = new Param("filename", Guid.NewGuid() + ".bmp"); parameters[1] = new Param("type", type); parameters[2] = new Param("device", GetMACAddress(wifi_RS21.NetworkSettings.PhysicalAddress)); parameters[3] = new Param("file"); string postData = this.GetPostData(parameters); //Get the byte[] System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[][] buffers = new byte[2][]; buffers[0] = encoding.GetBytes(postData); buffers[1] = picture; SendHttp(buffers, "uploadFile"); }
public string Decrypt(string input) { byte[] results; var utf8 = new System.Text.UTF8Encoding(); var hashProvider = new MD5CryptoServiceProvider(); var tdesKey = hashProvider.ComputeHash(utf8.GetBytes(_key)); var tdesAlgorithm = new TripleDESCryptoServiceProvider { Key = tdesKey, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 }; var dataToDecrypt = Convert.FromBase64String(input); try { ICryptoTransform decryptor = tdesAlgorithm.CreateDecryptor(); results = decryptor.TransformFinalBlock(dataToDecrypt, 0, dataToDecrypt.Length); } finally { tdesAlgorithm.Clear(); hashProvider.Clear(); } return(utf8.GetString(results)); }
public void TestCase() { TcpClient client = new TcpClient(); client.Connect("localhost", 27017); BufferedStream buff = new BufferedStream(client.GetStream()); BinaryWriter writer = new BinaryWriter(buff); System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); Byte[] msg = encoding.GetBytes("Hello MongoDB!"); writer.Write(16 + msg.Length + 1); writer.Write(1); writer.Write(1); writer.Write(1000); writer.Write(msg); writer.Write((byte)0); writer.Flush(); writer.Close(); client.Close(); }
/// <summary> /// Converts a string to a byte array using specified encoding. /// </summary> /// <param name="str">String to be converted.</param> /// <param name="encodingType">EncodingType enum.</param> /// <returns>byte array</returns> public static byte[] StringToByteArray(string str, EncodingType encodingType) { System.Text.Encoding encoding = null; switch (encodingType) { case EncodingType.ASCII: encoding = new System.Text.ASCIIEncoding(); break; case EncodingType.Unicode: encoding = new System.Text.UnicodeEncoding(); break; case EncodingType.UTF7: encoding = new System.Text.UTF7Encoding(); break; case EncodingType.UTF8: encoding = new System.Text.UTF8Encoding(); break; } return(encoding.GetBytes(str)); }
public static string GetDigestToDecode(string tamperProofParams) { string Digest = string.Empty; string input = string.Concat(SecretSalt, tamperProofParams, SecretSalt); //The array of bytes that will contain the encrypted value of input byte[] hashedDataBytes = null; //The encoder class used to convert strPlainText to an array of bytes System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding(); //Create an instance of the MD5CryptoServiceProvider class System.Security.Cryptography.MD5CryptoServiceProvider md5Hasher = new System.Security.Cryptography.MD5CryptoServiceProvider(); //Call ComputeHash, passing in the plain-text string as an array of bytes //The return value is the encrypted value, as an array of bytes hashedDataBytes = md5Hasher.ComputeHash(encoder.GetBytes(input)); //Base-64 Encode the results and strip off ending '==', if it exists Digest = Convert.ToBase64String(hashedDataBytes).TrimEnd("=".ToCharArray()); return(Digest); }
public void RenderText(int x, int y, string text, int fontSet) { if (fontSet > 1) { fontSet = 1; } int[] viewport = new int[4]; GL.GetInteger(GetPName.Viewport, viewport); GL.BindTexture(TextureTarget.Texture2D, TextureName); GL.Disable(EnableCap.DepthTest); GL.MatrixMode(MatrixMode.Projection); GL.PushMatrix(); // Save the projection matrix GL.LoadIdentity(); // Reset the projection matrix // Set up an ortho screen GL.Ortho(0, viewport [2], 0, viewport [3], -1, 1); GL.MatrixMode(MatrixMode.Modelview); GL.PushMatrix(); // Save the modelview matrix GL.LoadIdentity(); // Reset the modelview matrix GL.Translate(x, y, 0); // Position the text GL.ListBase(baseDL - 32 + (128 * fontSet)); // Choose the font set // Convert our string into a byte array for CallLists System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] textBytes = encoding.GetBytes(text); // Write the text to the screen // Draws the display list text GL.CallLists(text.Length, ListNameType.UnsignedByte, textBytes); GL.MatrixMode(MatrixMode.Projection); GL.PopMatrix(); // Restore the previous projection matrix GL.MatrixMode(MatrixMode.Modelview); GL.PopMatrix(); // Restore the previous modelview matrix GL.Enable(EnableCap.DepthTest); }
private void SendToEndpoint(string uri, string json) { try { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] bytes = encoding.GetBytes(json); var httpWebRequest = (HttpWebRequest)WebRequest.Create(uri); httpWebRequest.ContentType = "application/json;charset=utf-8"; httpWebRequest.Method = "POST"; httpWebRequest.ContentLength = bytes.Length; httpWebRequest.KeepAlive = false; httpWebRequest.Timeout = 2000; using (Stream requestStream = httpWebRequest.GetRequestStream()) { requestStream.Write(bytes, 0, bytes.Length); requestStream.Flush(); requestStream.Close(); } } catch (Exception e) { Debug.Print("Exception when sending data: " + e.Message); } }
static public string Post(string body) { string success = "SUCCESS"; HttpContent post = new StringContent(body, System.Text.Encoding.UTF8); post.Headers.ContentType = new MediaTypeHeaderValue("application/json"); string uri = "/api/logs?api-version=" + logAnalyticsApiVersion; string time = DateTime.UtcNow.ToString("R"); var utf8Encoding = new System.Text.UTF8Encoding(); int size = utf8Encoding.GetBytes(body).Length; //System.Text.Encoding.UTF8.GetBytes(body).Length; HttpResponseMessage response; try { BuildHeader("POST", size, time); response = httpClient.PostAsync(uri, post).Result; } catch (Exception e) { success = "FAIL"; response = new HttpResponseMessage(); } return(success); }
/// Encrypt some text and return an encrypted byte array. public static byte[] Encrypt(string clearText) { var inputBytes = UTFEncoder.GetBytes(clearText); using (var input = new MemoryStream(inputBytes)) { using (var output = new MemoryStream()) { var encryptor = _rm.CreateEncryptor(_key, _iv); using (var cryptStream = new CryptoStream(output, encryptor, CryptoStreamMode.Write)) { var buffer = new byte[1024]; var read = input.Read(buffer, 0, buffer.Length); while (read > 0) { cryptStream.Write(buffer, 0, read); read = input.Read(buffer, 0, buffer.Length); } cryptStream.FlushFinalBlock(); return(output.ToArray()); } } } }
public SmallString(string value, bool precacheHashCode = false) { _flags = _SmallFlags.None; _cachedHashCode = 0; if (!string.IsNullOrEmpty(value)) { if (precacheHashCode) { _flags |= _SmallFlags.HasHashCode; _cachedHashCode = value.GetHashCode(); } long numValue; if (long.TryParse(value, System.Globalization.NumberStyles.None, null, out numValue)) { _flags |= _SmallFlags.IsInt64; _encodedBytes = BitConverter.GetBytes(numValue); // It's possible that this doesn't round trip with full fidelity. // If this assert ever gets hit, consider adding an overload that opts // out of this optimization. // (Note that the parameters are not evaluated on retail builds) Assert.AreEqual(this.GetString(), value); return; } _encodedBytes = s_Encoder.GetBytes(value); Assert.IsNotNull(_encodedBytes); } else { _encodedBytes = null; } }