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;
}
}
