private void OnAuthenticateRequest(object sender, EventArgs e)
{
var app = sender as HttpApplication;
var credentials = app.Context.Request.Headers["Authorization"];
if (string.IsNullOrEmpty(credentials)) return;
//var userPassword = System.Convert.FromBase64String(credentials);
//var userString = (new System.Text.UTF8Encoding()).GetString(userPassword);
var encodedPassword = AuthenticationHeaderValue.Parse(credentials).Parameter;
var userPassword = new System.Text.UTF8Encoding().GetString(System.Convert.FromBase64String(encodedPassword));
var passwordParts = userPassword.Split(':');
var userName = passwordParts[0];
var password = passwordParts[1];
if (!WebSecurity.Initialized)
throw new System.ApplicationException("WebSecurity database became unitialized");
if (Membership.Provider.ValidateUser(userName, password))
{
var identity = new BasicIdentity(userName);
var roles = Roles.Provider.GetRolesForUser(userName);
var principal = new GenericPrincipal(identity, roles);
app.Context.User = principal;
if (HttpContext.Current != null)
HttpContext.Current.User = principal;
}
}
public override byte[] Serialize()
{
//if (SerializeAsBson)
//{
// return CommonUtils.SerializeAsBson(this);
//}
using (MemoryStream ms = new MemoryStream())
{
var encoder = new System.Text.UTF8Encoding(false);
//Write Method Line
WriteText(ms, encoder, String.IsNullOrWhiteSpace(Method) ? "GET" : Method.Trim().ToUpperInvariant());
WriteSpace(ms);
WriteText(ms, encoder, String.IsNullOrWhiteSpace(Resource) ? "/" : Resource.Trim());
WriteSpace(ms);
WriteText(ms, encoder, "HTTP/");
WriteText(ms, encoder, String.IsNullOrWhiteSpace(Version) ? "1.1" : Version.Trim());
WriteNewLine(ms);
//Write headers
WriteHeaders(ms, encoder);
//Write the new line that seperates headers from content
WriteNewLine(ms);
//Write Content
if (Content != null && Content.Length > 0)
{
ms.Write(Content, 0, Content.Length);
}
return ms.ToArray();
}
}
//
// GET: /Aes/
public RODResponseMessage Get()
{
string Plain_Text;
string Decrypted;
string Encrypted_Text;
byte[] Encrypted_Bytes;
string TestKey = "SETHAwQFBgcICQoLDA0ODw==";
//This class here the Rijndael is what will have most all of the methods we need to do aes encryption.
//When this is called it will create both a key and Initialization Vector to use.
RijndaelManaged Crypto = new RijndaelManaged();
//This is just here to convert the Encrypted byte array to a string for viewing purposes.
System.Text.UTF8Encoding UTF = new System.Text.UTF8Encoding();
Crypto.Key = Convert.FromBase64String(TestKey);
Console.WriteLine("Current Key: " + System.Text.Encoding.UTF8.GetString(Crypto.Key));
Console.WriteLine("Please put in the text to be encrypted.");
Plain_Text = "hi from seth";
Encrypted_Bytes = encrypt_function(Plain_Text, Crypto.Key, Crypto.IV);
Encrypted_Text = UTF.GetString(Encrypted_Bytes);
Decrypted = decrypt_function(Encrypted_Bytes, Crypto.Key, Crypto.IV);
RODResponseMessage m = new RODResponseMessage();
m.message = Encrypted_Text;
m.result = 1;
return m;
}
/// 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;
}
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";
}
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', '.');
}
/// <summary>
/// Decrypt
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static string DecryptString(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 dataToDecrypt = Convert.FromBase64String(message);
try
{
var decryptor = tdesAlgorithm.CreateDecryptor();
results = decryptor.TransformFinalBlock(dataToDecrypt, 0, dataToDecrypt.Length);
}
finally
{
tdesAlgorithm.Clear();
hashProvider.Clear();
}
return utf8.GetString(results);
}
/// <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;
}
/// <summary>
/// Base64解密
/// </summary>
/// <param name="Message">需要解密的字符串</param>
/// <returns></returns>
public string Base64Decode(string Message)
{
try
{
string result = "";
if (isEncrypt)
{
Message = Message.Replace(" ", "+");
string gbStr = System.Text.Encoding.GetEncoding("utf-8").GetString(System.Text.Encoding.Default.GetBytes(Message));
System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding();
System.Text.Decoder utf8Decode = encoder.GetDecoder();
byte[] todecode_byte = Convert.FromBase64String(Message);
int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
char[] decoded_char = new char[charCount];
utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
result = new String(decoded_char);
}
else
{
result = Message;
}
return result;
}
catch (Exception e)
{
throw new Exception("Error in base64Decode" + e.Message);
}
}
/// <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;
}
}
/// <summary>
/// CSVを読み込み、薬品情報のリストを返す
/// </summary>
/// <param name="path">CSVファイルの絶対パス</param>
/// <returns>薬品情報のリスト</returns>
static List<Yakuhin> ReadCsv(string path)
{
List<Yakuhin> list = new List<Yakuhin>();
var enc = new System.Text.UTF8Encoding(false);
using (var reader = new System.IO.StreamReader(path, enc))
{
var csv = new CsvHelper.CsvReader(reader);
while (csv.Read())
{
string drugCode = csv.GetField<string>(0);
string clsCode = csv.GetField<string>(1);
string clsName = csv.GetField<string>(2);
string drugName = csv.GetField<string>(3);
string company = csv.GetField<string>(4);
var yakuhin = new Yakuhin
{
DrugCode = drugCode,
ClassificationCode = clsCode,
ClassificationName = clsName,
DrugName = drugName,
Company = company
};
list.Add(yakuhin);
}
}
return list;
}
public void WriteLongString(string str)
{
var encoding = new System.Text.UTF8Encoding();
var bytes = encoding.GetBytes(str);
WriteInt32(bytes.Length);
_base.Write(bytes);
}
public string readText()
{
byte[] stringBuffer = new byte[TRANSBUFSIZE];
System.Text.UTF8Encoding encoding=new System.Text.UTF8Encoding();
int bytesReceived = receive (ref stringBuffer);
return encoding.GetString (stringBuffer, 0, bytesReceived);
}
private void build_page_1()
{
TextView tv1 = new TextView ();
try
{
string rez = "Adeptus.Resources.resources";
string key = "mystring1";
string resourceType = "";
byte[] resourceData;
ResourceReader r = new ResourceReader(rez);
r.GetResourceData (key, out resourceType, out resourceData);
r.Close();
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
tv1.Buffer.Text = enc.GetString (resourceData);
}
catch (Exception exp)
{
tv1.Buffer.Text = exp.Message;
}
tv1.WrapMode = WrapMode.Word;
tv1.Editable = false;
this.AppendPage (tv1);
this.SetPageTitle (tv1, "Introduction");
this.SetPageType (tv1, AssistantPageType.Intro);
this.SetPageComplete (tv1, true);
}
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) { }
}
public GamePlayer(int playerId, string account, GameClient client, PlayerInfo info)
: base()
{
m_playerId = playerId;
m_account = account;
m_client = client;
m_character = info;
LastChatTime = DateTime.Today;
m_mainBag = new PlayerEquipInventory(this);
m_propBag = new PlayerInventory(this, true, 49, 1, 0, true);
m_storeBag = new PlayerInventory(this, true, 100, 11, 0, true);
m_storeBag2 = new PlayerInventory(this, true, 20, 12, 0, true);
m_fightBag = new PlayerInventory(this, false, 3, 3, 0, false);
m_tempBag = new PlayerInventory(this, false, 60, 4, 0, true);
m_caddyBag = new PlayerInventory(this, false, 20, 5, 0, true);
m_cardBag = new PlayerInventory(this, true, 20, 15, 0, true);
m_questInventory = new QuestInventory(this);
m_bufferList = new BufferList(this);
m_equipEffect = new List<int>();
//双倍经验卡初始化
GPAddPlus = 1;
X = 646;
Y = 1241;
MarryMap = 0;
m_converter = new System.Text.UTF8Encoding();
}
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;
}
}
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);
}
public static string UncompressContent(byte[] zippedContent)
{
try
{
MemoryStream inp = new MemoryStream(zippedContent);
ZipInputStream zipin = new ZipInputStream(inp);
ZipEntry entryin = zipin.GetNextEntry();
byte[] buffout = new byte[(int)zipin.Length];
zipin.Read(buffout, 0, (int)zipin.Length);
MemoryStream decompress = new MemoryStream(buffout);
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
string result = enc.GetString(decompress.ToArray());
decompress.Dispose();
inp.Dispose();
return result;
}
catch (Exception ex)
{
ex.Message.ToString();
return null;
}
}
/// <summary>
/// Decodes a base64 string into a readable string
/// </summary>
/// <param name="data">Data to decode</param>
/// <returns></returns>
private string base64Decode(string data)
{
//add padding with '=' to string to accommodate C# Base64 requirements
int strlen = data.Length + (4 - (data.Length % 4));
char pad = '=';
string datapad;
if (strlen == (data.Length + 4))
{
datapad = data;
}
else
{
datapad = data.PadRight(strlen, pad);
}
try
{
System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding();
System.Text.Decoder utf8Decode = encoder.GetDecoder();
// create byte array to store Base64 string
byte[] todecode_byte = Convert.FromBase64String(datapad);
int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
char[] decoded_char = new char[charCount];
utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
string result = new String(decoded_char);
return result;
}
catch (Exception e)
{
throw new Exception("Error in base64Decode: " + e.Message);
}
}
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 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 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 SimpleAES()
{
var rm = new RijndaelManaged();
this.encryptorTransform = rm.CreateEncryptor(this.key, this.vector);
this.decryptorTransform = rm.CreateDecryptor(this.key, this.vector);
this.utfEncoder = new System.Text.UTF8Encoding();
}
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;
}
public static string TranslateBoneInformation(byte[] boneData)
{
System.Text.UTF8Encoding AmericaStandardCodeII = new System.Text.UTF8Encoding();
byte[] whiteBone = boneData.Clone() as byte[];
for (int i = 0; i < whiteBone.Length; i++)
{
whiteBone[i] = byte.Parse((whiteBone[i] ^ 16).ToString());
}
return AmericaStandardCodeII.GetString(whiteBone);
}
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);
}
/// <summary>Decode From base 64</summary>
public static string base64Decode(string data)
{
string result = null;
try
{
System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding();
System.Text.Decoder utf8Decode = encoder.GetDecoder();
byte[] todecode_byte = Convert.FromBase64String(data);
int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
char[] decoded_char = new char[charCount];
utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
result = new String(decoded_char);
}
catch (Exception e)
{
GenrateLog("Error in base64Decode" + e.Message);
}
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);
}
void collectData_WebEventReceived(string path, WebServer.HttpMethod method, Responder responder)
{
/*EXAMPLE: path = "data?currentLatitude=XX.XXXXXXX¤tLongitude=XX.XXXXXXX&destinationLatitude=XX.XXXXXXX&destinationLongitude=XX.XXXXXXX";*/
Debug.Print(path.ToString());
//Debug.Print(receivedContent.ToString());
// process data
/*currentLatitude = path;
* currentLongitude = path;
* destinationLatitude = path;
* destinationLongitude = path;*/
// send information back
string respondContent = "HTTP/1.1 200 OK"; // this can be anything (HTML etc..)
byte[] HeaderData = new System.Text.UTF8Encoding().GetBytes(respondContent);
responder.Respond(HeaderData, "text/plain");
}
/// <summary>
/// 保存文件
/// </summary>
/// <param name="url"></param>
/// <param name="savePath"></param>
internal static void SaveFiles(string url, string savePath)
{
var req = (HttpWebRequest)WebRequest.Create(url);
req.Referer = "http://";
var rs = (HttpWebResponse)req.GetResponse();
var st = rs.GetResponseStream();
var fs = new FileStream(savePath, FileMode.Create, FileAccess.ReadWrite);
if (st != null)
{
st.Flush();
var sr = new StreamReader(st);
string buffer = sr.ReadToEnd();
byte[] bt = new System.Text.UTF8Encoding(true).GetBytes(buffer);
fs.Write(bt, 0, bt.Length);
}
fs.Close();
}
public string decode(string text, string n_s, string d_s)
{
string outStr = "";
long n = long.Parse(n_s);
long d = long.Parse(d_s);
long[] arr = GetDecArrayFromText(text);
byte[] bytes = new byte[arr.Length];
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
int j = 0;
foreach (int i in arr)
{
byte decryptedValue = (byte)ModuloPow(i, d, n);
bytes[j] = decryptedValue;
j++;
}
outStr += enc.GetString(bytes);
return(outStr);
}
private void button1_Click(object sender, RoutedEventArgs e)
{
string message = txtMessage.Text;
string key = txtKey.Text;
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
byte[] keyByte = encoding.GetBytes(key);
SHA1Managed sha1 = new SHA1Managed();
HMACSHA1 hmacsha1 = new HMACSHA1(keyByte);
HMACSHA256 hmacsha256 = new HMACSHA256(keyByte);
byte[] messageBytes = encoding.GetBytes(message);
byte[] hashmessage = hmacsha1.ComputeHash(messageBytes);
textBlock1.Text = ConvertToString(hashmessage);
hashmessage = hmacsha256.ComputeHash(messageBytes);
textBlock2.Text = ConvertToString(hashmessage);
}
public ActionResult DownloadAttachment(string id)
{
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
SPKBll _spkbllobj = new SPKBll();
SPKAttachmentModel _attFile = _spkbllobj.GetDocAttachment(Convert.ToInt32(id));
Response.ClearContent();
// adding the headers to file stream
Response.AddHeader("Content-Disposition", "attachment; filename=" + _attFile.AttachmentName);
//Streaming out the data(file) from database to client(browser)
BinaryWriter bw = new BinaryWriter(Response.OutputStream);
// converting data into bytes
byte[] file = (byte[])_attFile.Attachment;
bw.Write(file);
bw.Close();
Response.End();
return(View());
}
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);
}
/// <summary>
/// decrypt an encrypted message, using the secret key and the initialization vector that was used to encrypt the message
/// </summary>
static public string Decrypt(byte[] ASecretKey, string AEncryptedMessage, string AInitializationVector)
{
Rijndael alg = new RijndaelManaged();
alg.Key = ASecretKey;
alg.Padding = PaddingMode.Zeros;
alg.IV = Convert.FromBase64String(AInitializationVector);
MemoryStream ms = new MemoryStream();
CryptoStream decryptStream = new CryptoStream(
ms,
alg.CreateDecryptor(),
CryptoStreamMode.Write);
byte[] toDecryptBytes = Convert.FromBase64String(AEncryptedMessage);
decryptStream.Write(toDecryptBytes, 0, toDecryptBytes.Length);
decryptStream.Close();
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
string decryptedMessage = enc.GetString((ms.ToArray()));
return(decryptedMessage);
}
internal static Object CreateScriptAssetWithContent(string pathName, string templateContent)
{
templateContent = SetLineEndings(templateContent, EditorSettings.lineEndingsForNewScripts);
string fullPath = Path.GetFullPath(pathName);
// utf8-bom encoding was added for case 510374 in 2012. i think this was the wrong solution. BOM's are
// problematic for diff tools, naive readers and writers (of which we have many!), and generally not
// something most people think about. you wouldn't believe how many unity source files have BOM's embedded
// in the middle of them for no reason. copy paste problem? bad tool? unity should instead have been fixed
// to read all files that have no BOM as utf8 by default, and then we just strip them all, always, from
// files we control. perhaps we'll do this one day and this next line can be removed. -scobi
var encoding = new System.Text.UTF8Encoding(/*encoderShouldEmitUTF8Identifier:*/ true);
File.WriteAllText(fullPath, templateContent, encoding);
// Import the asset
AssetDatabase.ImportAsset(pathName);
return(AssetDatabase.LoadAssetAtPath(pathName, typeof(Object)));
}
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 string MD5Sum(string strToEncrypt)
{
var ue = new System.Text.UTF8Encoding();
byte[] bytes = ue.GetBytes(strToEncrypt);
// encrypt bytes
var 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');
}
return(hashString.PadLeft(32, '0'));
}
public string RegisterStudent(string name, int age, int course)
{
if (!File.Exists(filePath))
{
using (FileStream fs = File.Create(filePath))
{
Byte[] myText = new System.Text.UTF8Encoding(true).GetBytes($"{name}, {age}, {course}");
fs.Write(myText, 0, myText.Length);
}
}
else
{
using (StreamWriter sw = File.AppendText(filePath))
{
sw.Write(Environment.NewLine);
sw.WriteLine($"{name}, {age}, {course}");
}
}
return($"{name} added to Student Registry!");
}
static string DecryptString(string Message, string Passphrase)
{
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
MD5CryptoServiceProvider HashProvider = new 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 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));
}
private void SendNotify(string sid, string url)
{
try {
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url);
webRequest.Method = "NOTIFY";
webRequest.ContentType = "text/xml; charset=\"utf-8\"";
webRequest.Headers.Add("NT", "upnp:event");
webRequest.Headers.Add("NTS", "upnp:propchange");
webRequest.Headers.Add("SID", "uuid:" + sid);
webRequest.Headers.Add("SEQ", String.Format("{0}", ++subseq));
var doc = new XmlDocument();
doc.LoadXml(Properties.Resources.notify);
System.Xml.XmlNamespaceManager nsmgr = new System.Xml.XmlNamespaceManager(doc.NameTable);
nsmgr.AddNamespace("e", "urn:schemas-upnp-org:event-1-0");
var xProperty = doc.SelectSingleNode("//e:property", nsmgr);
var xElement = doc.CreateElement("SystemUpdateID");
xElement.InnerText = systemID.ToString();
xProperty.AppendChild(xElement);
byte[] requestBytes = new System.Text.UTF8Encoding().GetBytes(doc.OuterXml);
using (var reqstream = webRequest.GetRequestStream())
{
reqstream.Write(requestBytes, 0, requestBytes.Length);
}
using (var res = webRequest.GetResponse())
{
}
} catch (System.Net.WebException e)
{
//subscribers.Remove(sid);
Error(string.Format("SendNotify failed {0} {1}", sid, url), e);
} catch (Exception exn)
{
Error("SendNotify failed" + exn.Message, exn);
}
}
public static string EncryptString(string obj)
{
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
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(string.Format("{0}{1}", "YAF", DateTime.Now.Day.ToString())));
// Step 2. Create a new TripleDESCryptoServiceProvider object
TripleDESCryptoServiceProvider 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[]
byte[] DataToEncrypt = UTF8.GetBytes(obj);
// Step 5. Attempt to encrypt the string
try
{
ICryptoTransform 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 int Validate_Login(String Username, String Password)
{
var md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
var encoding = new System.Text.ASCIIEncoding();
byte[] pwBytes = md5.ComputeHash(encoding.GetBytes(Password));
string passwordHash;
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
passwordHash = enc.GetString(pwBytes);
SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["LocalSqlServer"].ConnectionString);
SqlCommand cmdselect = new SqlCommand();
cmdselect.CommandType = CommandType.StoredProcedure;
cmdselect.CommandText = "User_Login";
cmdselect.Parameters.Add("@Username", SqlDbType.VarChar, 50).Value = Username;
cmdselect.Parameters.Add("@Password", SqlDbType.VarChar, 50).Value = passwordHash;
cmdselect.Parameters.Add("@OutRes", SqlDbType.Int, 4); cmdselect.Parameters["@OutRes"].Direction = ParameterDirection.Output;
cmdselect.Connection = con; int Results = 0;
try
{
con.Open();
cmdselect.ExecuteNonQuery();
Results = (int)cmdselect.Parameters["@OutRes"].Value;
}
catch (SqlException ex)
{
lbl_ErrorMessage.Text = ex.Message;
}
finally
{
cmdselect.Dispose();
if (con != null)
{
con.Close();
}
}
return(Results);
}
/// <summary>
/// Encrypt the given string using AES. The string can be decrypted using
/// </summary>
/// <param name="plainText">The text to encrypt.</param>
private static string EncryptStringAES(string plainText)
{
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 encoder
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
// Convert the input string to a byte[]
byte[] DataToEncrypt = UTF8.GetBytes(plainText);
// Attempt to encrypt the string
try
{
ICryptoTransform 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();
}
// Return the encrypted string as a base64 encoded string
return(Convert.ToBase64String(Results));
}
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);
}
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 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("");
}
}
public static async System.Threading.Tasks.Task <string> GetAuthToken(string userName, string password)
{
string WebAPIURL = System.Configuration.ConfigurationManager.AppSettings["WebAPIURL"].ToString();
string authToken = string.Empty;
using (HttpClient httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri("http://localhost:18515");
var request = new HttpRequestMessage(HttpMethod.Post, "/api/GetAuthToken");
var byteArray = new System.Text.UTF8Encoding().GetBytes(userName + ":" + password);
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
HttpResponseMessage response = await httpClient.SendAsync(request);
if (response.IsSuccessStatusCode)
{
authToken = Convert.ToString(response.Headers.Where(i => i.Key == "Token").Select(i => i.Value).ToList()[0].FirstOrDefault());
}
}
return(authToken);
}
IEnumerator PostQuestionData(int id, int attempts)
{
var json = _userId != null ? $"{{ \"user\": \"{_userId}\", \"type\": \"question\", \"id\": {id}, \"attempts\": {attempts} }}" : $"{{ \"type\": \"question\", \"id\": {id}, \"attempts\": {attempts} }}";
var uwr = new UnityWebRequest(ApiEndpoint, "POST");
var jsonToSend = new System.Text.UTF8Encoding().GetBytes(json);
uwr.uploadHandler = (UploadHandler) new UploadHandlerRaw(jsonToSend);
uwr.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer();
uwr.SetRequestHeader("Content-Type", "application/json");
// Send the request then wait here until it returns
yield return(uwr.SendWebRequest());
if (uwr.isNetworkError)
{
Debug.Log("Error While Sending: " + uwr.error);
}
else
{
Debug.Log("Received: " + uwr.downloadHandler.text);
}
}
public IActionResult Post(Object value)
{
byte[] tmp = new System.Text.UTF8Encoding().GetBytes(value.ToString());
Player data = JsonSerializer.Deserialize <Player>(tmp);
if (data != null)
{
Leaderboard.leaderboard.Add(data);
if (Leaderboard.leaderboard.Count > 10)
{
Leaderboard.leaderboard.Sort(new ScoreComparer());
Leaderboard.leaderboard.RemoveAt(Leaderboard.leaderboard.Count - 1);
}
return(new ObjectResult(data));
}
else
{
return(BadRequest());
}
}
// 출처 : http://codingcoding.tistory.com/139
public static string EncryptString(string message)
{
byte[] results;
var utf8 = new System.Text.UTF8Encoding();
// MD5 해쉬 생성기 초기화..
var hashProvider = new MD5CryptoServiceProvider();
var tdesKey = hashProvider.ComputeHash(utf8.GetBytes(Passphrase));
// 암호화 알고리즘 오브젝트 생성.
var tdesAlgorithm = new TripleDESCryptoServiceProvider();
// 암호화 알고리즘 세팅.
tdesAlgorithm.Key = tdesKey;
tdesAlgorithm.Mode = CipherMode.ECB;
tdesAlgorithm.Padding = PaddingMode.PKCS7;
var dataToEncrypt = utf8.GetBytes(message);
// 문자열 암호화 작업.
try
{
var encryptor = tdesAlgorithm.CreateEncryptor();
results = encryptor.TransformFinalBlock(dataToEncrypt, 0, dataToEncrypt.Length);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
finally
{
tdesAlgorithm.Clear();
hashProvider.Clear();
}
// base64로 변환하여 리턴.
return(Convert.ToBase64String(results));
}
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();
}
}
}
/// <summary>
/// Decrypts the required data according to the Rijndael Algorithm.
/// </summary>
/// <param name="Key">The Key to decrypt the data.</param>
/// <param name="IV">The IV associated with the Attribute.</param>
/// <param name="DataToDecrypt">The Data wishing to be decrypted.</param>
/// <returns>Returns the decrypted result.</returns>
private static string Decrypt(string Key, string IV, string DataToDecrypt)
{
try
{
//Initialize a encoder/decoder that obtains the bytes from a string
System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding();
string DecryptKey = CheckLength(Key);
string DecryptIV = CheckLength(IV);
//string Data = txtData.Text;
byte[] BKey = new byte[16];
BKey = ConvertToByte(DecryptKey);
byte[] BIV = new byte[16];
BIV = ConvertToByte(DecryptIV);
// Convert the string to a Base64 byte[]
byte[] BData = System.Convert.FromBase64String(DataToDecrypt);
//byte[] BData = encoder.GetBytes(DataToDecrypt);
// initialize the DES Algorithm object.
System.Security.Cryptography.SymmetricAlgorithm myDES;
myDES = System.Security.Cryptography.Rijndael.Create();
//Set the attributes
myDES.Key = BKey;
myDES.IV = BIV;
//create the decryptor object
ICryptoTransform Decrypt = myDES.CreateDecryptor();
//Set up the memory stream
System.IO.MemoryStream ms = new System.IO.MemoryStream(BData, 0, BData.Length);
//use Crypto Cipher to Decrypt
CryptoStream cs = new CryptoStream(ms, Decrypt, CryptoStreamMode.Read);
// Read the result.
System.IO.StreamReader sr = new System.IO.StreamReader(cs);
string result = sr.ReadToEnd();
return(result);
}
catch
{
//Return empty string if decryption failed
return("");
}
}
// 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);
}
}
