// public methods
/// <summary>
/// Static method that computes a combined key from issue and requester entropy using PSHA1 according to WS-Trust
/// </summary>
/// <param name="requestorEntropy">Entropy provided by the requester</param>
/// <param name="issuerEntropy">Entropy provided by the issuer</param>
/// <param name="keySize">Size of required key, in bits</param>
/// <returns>Array of bytes that contain key material</returns>
public static byte[] ComputeCombinedKey(byte[] requestorEntropy, byte[] issuerEntropy, int keySize)
{
KeyedHashAlgorithm kha = new HMACSHA1(requestorEntropy, true);
byte[] key = new byte[keySize / 8]; // Final key
byte[] a = issuerEntropy; // A(0)
byte[] b = new byte[kha.HashSize / 8 + a.Length]; // Buffer for A(i) + seed
for (int i = 0; i < key.Length;)
{
// Calculate A(i+1).
kha.Initialize();
a = kha.ComputeHash(a);
// Calculate A(i) + seed
a.CopyTo(b, 0);
issuerEntropy.CopyTo(b, a.Length);
kha.Initialize();
byte[] result = kha.ComputeHash(b);
for (int j = 0; j < result.Length; j++)
{
if (i < key.Length)
{
key[i++] = result[j];
}
else
{
break;
}
}
}
return(key);
}
public static byte[] ComputeCombinedKey(byte[] requestorEntropy, byte[] issuerEntropy, int keySize)
{
if (keySize < 64 || keySize > 4096)
{
throw new ArgumentOutOfRangeException("keySize");
}
KeyedHashAlgorithm keyedHashAlgorithm = new HMACSHA1(requestorEntropy, true);
byte[] array = new byte[keySize / 8];
byte[] array2 = issuerEntropy;
byte[] array3 = new byte[keyedHashAlgorithm.HashSize / 8 + array2.Length];
int i = 0;
while (i < array.Length)
{
keyedHashAlgorithm.Initialize();
array2 = keyedHashAlgorithm.ComputeHash(array2);
array2.CopyTo(array3, 0);
issuerEntropy.CopyTo(array3, array2.Length);
keyedHashAlgorithm.Initialize();
byte[] array4 = keyedHashAlgorithm.ComputeHash(array3);
int num = 0;
while (num < array4.Length && i < array.Length)
{
array[i++] = array4[num];
num++;
}
}
return(array);
}
/// <summary>
/// 计算一个字典的签名。
///
/// </summary>
/// <param name="paramsMap">字典</param>
/// <param name="secretKey">密钥，base64编码过的64字节的Key</param>
/// <returns>base64字符串</returns>
public static String ComputeSignature(Dictionary <String, String> paramsMap, String secretKey)
{
byte[] key = System.Convert.FromBase64String(secretKey);
HMACSHA1 myhmacsha1 = new HMACSHA1(key);
myhmacsha1.Initialize();
List <String> keyList = new List <string>();
keyList.AddRange(paramsMap.Keys);
keyList.Sort();
StringBuilder sb = new StringBuilder();
byte[] b = null;
foreach (var keyItem in keyList)
{
//b = Encoding.UTF8.GetBytes(keyItem);
sb.Append(keyItem);
if (!String.IsNullOrEmpty(paramsMap[keyItem]))
{
sb.Append(paramsMap[keyItem]);
}
}
//String r = myhmacsha1.ComputeHash(ms).Aggregate("", (s, e) => s + String.Format("{0:x2}", e), s => s);
Console.WriteLine(sb.ToString());
//char[] cs = r.ToCharArray();
b = myhmacsha1.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()));
return(System.Convert.ToBase64String(b));
}
public static byte[] HmacSha1(byte[] data, byte[] key)
{
HMACSHA1 hmac = new HMACSHA1(key);
hmac.Initialize();
return(hmac.ComputeHash(data));
}
public void Auth()
{
// setup connection to endpoint
request = WebRequest.Create(baseUrl + "auth");
// compute HMAC
var enc = Encoding.ASCII;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(privateKey));
hmac.Initialize();
var timestamp = DateTime.Now.ToString(@"MM\/dd\/yyyy hh\:mm");
byte[] buffer = enc.GetBytes(publicKey + timestamp + salt);
var hash = BitConverter.ToString(hmac.ComputeHash(buffer)).Replace("-", "").ToLower();
request.Headers ["X-Coursio-apikey"] = publicKey;
request.Headers ["X-Coursio-time"] = timestamp;
request.Headers ["X-Coursio-random"] = salt;
request.Headers ["X-Coursio-hmac"] = hash;
request.Method = "POST";
byte[] byteArray = Encoding.UTF8.GetBytes("{\"method\":\"loginHmac\"}");
// Set the ContentLength property of the WebRequest.
request.ContentLength = byteArray.Length;
// Write data to the Stream
Stream dataStream = request.GetRequestStream();
dataStream.Write(byteArray, 0, byteArray.Length);
dataStream.Close();
// Get the response.
WebResponse response = request.GetResponse();
// Get the stream content and read it
Stream dataStream2 = response.GetResponseStream();
StreamReader reader = new StreamReader(dataStream2);
// Read the content.
string responseFromServer = reader.ReadToEnd();
// Clean up
reader.Close();
dataStream2.Close();
response.Close();
Regex regex = new Regex(@"""sessionId"":""(.*?)""");
Match match = regex.Match(responseFromServer);
if (match.Success)
{
sessionId = match.Groups[1].Value;
}
else
{
throw new System.Exception("Login failed");
}
}
/// <summary>
/// Generates a PIN of desired length when given a challenge (counter)
/// </summary>
/// <param name="challenge">Counter to calculate hash</param>
/// <returns>Desired length PIN</returns>
private String generateResponseCode(long challenge, byte[] randomBytes)
{
//create hmacsha1 instance and init
HMACSHA1 myHmac = new HMACSHA1(randomBytes);
myHmac.Initialize();
//convert interval to bytes
byte[] value = BitConverter.GetBytes(challenge);
Array.Reverse(value); //reverses the challenge array due to differences in c# vs java
myHmac.ComputeHash(value);
//Get hash
byte[] hash = myHmac.Hash;
int offset = hash[hash.Length - 1] & 0xF;
byte[] selectedFourBytes = new byte[4];
//selected bytes are actually reversed due to c# again, thus the weird stuff here
selectedFourBytes[0] = hash[offset];
selectedFourBytes[1] = hash[offset + 1];
selectedFourBytes[2] = hash[offset + 2];
selectedFourBytes[3] = hash[offset + 3];
Array.Reverse(selectedFourBytes);
int finalInt = BitConverter.ToInt32(selectedFourBytes, 0);
int truncatedHash = finalInt & 0x7FFFFFFF; //remove the most significant bit for interoperability as per HMAC standards
int pinValue = truncatedHash % pinModulo; //generate 10^d digits where d is the number of digits
return(padOutput(pinValue));
}
private static string Base64EncodeHash(string url)
{
byte[] result;
HMACSHA1 shaM = new HMACSHA1();
shaM.Key = new byte[2];
byte[] ms = new byte[url.Length];
for (int i = 0; i < url.Length; i++)
{
byte b = Convert.ToByte(url[i]);
ms[i] = (b);
}
shaM.Initialize();
result = shaM.ComputeHash(ms, 0, ms.Length);
string hash = System.Convert.ToBase64String(result);
return(System.Web.HttpUtility.UrlEncode(hash));
}
public TwitterCryptor(string consumerSecret, string oauthTokenSecret = null)
{
string signingKey = RFC3986.Encode(consumerSecret) + '&' + RFC3986.Encode(oauthTokenSecret);
m_Crypto = new HMACSHA1(Encoding.ASCII.GetBytes(signingKey));
m_Crypto.Initialize();
}
public static string GetS3SignedPlayer(string url)
{
url = url ?? "https://s3-sa-east-1.amazonaws.com/mgunauthpermission/imageUniRio.png";
var accessKey = Constants.ACCESSKEY;
var secretKey = Constants.SECRETKEY;
var r = ((int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds + 3600) / 60.0;
var expires = Math.Round(r) * 60;
var enc = Encoding.ASCII;
var encUtf = Encoding.UTF8;
HMACSHA1 hmac = new HMACSHA1(encUtf.GetBytes(secretKey));
hmac.Initialize();
var VERB = "GET";
var resource = (new Uri(url)).AbsolutePath;
var host = (new Uri(url)).AbsoluteUri.Replace(resource, "");
var signatureString = String.Concat(VERB, "\n", "\n", "\n", expires, "\n", resource);
byte[] buffer = encUtf.GetBytes(signatureString);
var signature = ToUrlSafeBase64String(hmac.ComputeHash(buffer));
return(String.Concat(host, resource, "?AWSAccessKeyId=", accessKey, "&Expires=", expires, "&Signature=", HttpUtility.UrlEncode(signature)));
}
private static string ToHMAC_SHA1(string password, string key, EncodingType encodingType)
{
using var hmacSha = new HMACSHA1(Encoding.UTF8.GetBytes(key));
hmacSha.Initialize();
return(Encode(hmacSha.ComputeHash(Encoding.UTF8.GetBytes(password)), encodingType));
}
public static string CalculateCode(string _key, long _tick = -1)
{
if (_tick == -1)
{
TimeSpan _timeSpan = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
long _currentTimeSeconds = (long)Math.Floor(_timeSpan.TotalSeconds);
_tick = _currentTimeSeconds / Authenticator.INTERVAL_LENGTH;
}
byte[] _keyByteArray = Base32.Decode(_key);
HMACSHA1 _myHmac = new HMACSHA1(_keyByteArray);
_myHmac.Initialize();
byte[] _value = BitConverter.GetBytes(_tick);
Array.Reverse(_value);
_myHmac.ComputeHash(_value);
byte[] _hash = _myHmac.Hash;
int _offset = _hash[_hash.Length - 1] & 0xF;
byte[] _fourBytes = new byte[4];
_fourBytes[0] = _hash[_offset];
_fourBytes[1] = _hash[_offset + 1];
_fourBytes[2] = _hash[_offset + 2];
_fourBytes[3] = _hash[_offset + 3];
Array.Reverse(_fourBytes);
int _finalInt = BitConverter.ToInt32(_fourBytes, 0);
int _truncatedHash = _finalInt & 0x7FFFFFFF;
int _pinValue = _truncatedHash % (int)Math.Pow(10, Authenticator.PIN_LENGTH);
return(_pinValue.ToString().PadLeft(Authenticator.PIN_LENGTH, '0'));
}
private static byte[] hash_hmac_byte(string signatureString, string secretKey)
{
var enc = Encoding.UTF8; HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(secretKey));
hmac.Initialize();
byte[] buffer = enc.GetBytes(signatureString);
return(hmac.ComputeHash(buffer));
}
/// <summary>
/// Generates signature for douban api
/// </summary>
/// <param name="api">Douban api path, e.g. /api/v2/search/movie</param>
/// <param name="ts">Timestamp.</param>
/// <returns>Douban signature</returns>
public static string GetSigParam(string api, string ts)
{
using var hmacsha1 = new HMACSHA1(Encoding.UTF8.GetBytes(SecretKey));
hmacsha1.Initialize();
byte[] data = hmacsha1.ComputeHash(Encoding.UTF8.GetBytes($"GET&{UrlEncodeInUpperCase(api)}&{ts}"));
return(Convert.ToBase64String(data));
}
private string createSign(HttpWebRequest request, string path)
{
HMACSHA1 hmacsha1 = new HMACSHA1();
hmacsha1.Initialize();
hmacsha1.Key = Encoding.Default.GetBytes(this.secret_key);
byte[] final = hmacsha1.ComputeHash(Encoding.Default.GetBytes(createSignString(request, path)));
return(Convert.ToBase64String(final));
}
/// <summary>
/// 生成基于哈希的消息验证代码
/// </summary>
/// <param name="signatureString"></param>
/// <param name="secretKey"></param>
/// <returns></returns>
private byte[] CreateHmacSha(string signString, string secretKey)
{
var encoding = Encoding.UTF8;
HMACSHA1 hmacsha = new HMACSHA1(encoding.GetBytes(secretKey));
hmacsha.Initialize();
byte[] buffer = encoding.GetBytes(signString);
return(hmacsha.ComputeHash(buffer));
}
/// <summary>
/// Signs the input with the key provided
/// </summary>
/// <param name="input">Data to be signed</param>
/// <param name="key">Key used for signing</param>
/// <returns>Base64 encoded signed data</returns>
public static string SignHMAC(byte[] input, byte[] key)
{
using (HMACSHA1 hmac = new HMACSHA1(key))
{
hmac.Initialize();
var signature = hmac.ComputeHash(input);
return(Convert.ToBase64String(signature));
}
}
private static string hash_hmac(string signatureString, string secretKey)
{
var enc = Encoding.UTF8;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(secretKey));
hmac.Initialize();
byte[] buffer = enc.GetBytes(signatureString);
return(BitConverter.ToString(hmac.ComputeHash(buffer)).Replace("-", "").ToLower());
}
static string hmac1(char[] secretKey, char[] signatureString)
{
var enc = Encoding.ASCII;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(secretKey));
hmac.Initialize();
byte[] buffer = enc.GetBytes(signatureString);
return(BitConverter.ToString(hmac.ComputeHash(buffer)).Replace("-", "").ToLower());
}
public static string HmacSha1ToBase64(string signatureString, string secretKey)
{
var enc = Encoding.UTF8;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(secretKey));
hmac.Initialize();
byte[] buffer = enc.GetBytes(signatureString);
return(Convert.ToBase64String(hmac.ComputeHash(buffer)).Trim());
}
/// <summary>
/// UTF8 !
/// </summary>
/// <param name="tobeSigned"></param>
/// <returns></returns>
public static string HMAC_SHA1_Encoding(string tobeSigned)
{
using (HMACSHA1 hmac = new HMACSHA1(System.Text.Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings["ePayClientSecret"])))
{
hmac.Initialize();
byte[] encodedBytes = System.Text.Encoding.UTF8.GetBytes(tobeSigned);
return(BitConverter.ToString(hmac.ComputeHash(encodedBytes)).Replace("-", "").ToLower());
}
}
public static byte[] CalculateHMACSHA1(string data, string key)
{
var enc = System.Text.Encoding.UTF8;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(key));
hmac.Initialize();
byte[] buffer = enc.GetBytes(data);
return(hmac.ComputeHash(buffer));
}
private string hash_hmac(string signatureString, string secretKey)
{
var enc = Encoding.UTF8;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(secretKey));
hmac.Initialize();
byte[] buffer = enc.GetBytes(signatureString);
return(Convert.ToBase64String(hmac.ComputeHash(buffer)));
}
private static byte[] HMACSHA1(string signatureString, string secretKey)
{
var sh1 = new HMACSHA1(UTF8Bytes(secretKey));
sh1.Initialize();
var buffer = UTF8Bytes(signatureString);
return(sh1.ComputeHash(buffer));
}
public static string HashHMAC(string PublicKey, string PrivateKey)
{
var enc = Encoding.UTF8;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(PrivateKey));
hmac.Initialize();
byte[] buffer = enc.GetBytes(PublicKey);
return(Convert.ToBase64String(hmac.ComputeHash(buffer)));
}
// ReSharper disable once InconsistentNaming
public string HashHMACSHA1WithoutBase64(string message, string secret)
{
var enc = Encoding.ASCII;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(secret));
hmac.Initialize();
byte[] buffer = enc.GetBytes(message);
return(BitConverter.ToString(hmac.ComputeHash(buffer)).Replace("-", "").ToLower());
}
private string HmacSha1(string encoded, string secret)
{
var enc = Encoding.ASCII;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(secret));
hmac.Initialize();
byte[] buffer = enc.GetBytes(encoded);
return(BitConverter.ToString(hmac.ComputeHash(buffer)).Replace("-", "").ToLower());
}
private string calculateHmac(string encoded)
{
var hmac = new HMACSHA1(Encoding.ASCII.GetBytes(settings.Secret));
hmac.Initialize();
byte[] buffer = Encoding.ASCII.GetBytes(encoded);
string checksum = BitConverter.ToString(hmac.ComputeHash(buffer)).Replace("-", "").ToLower();
return(checksum);
}
/// <summary>
/// Generates the encrypted password to append to the end of a request URI.
/// </summary>
/// <param name="url">request URI without "&pass="******"string"/> of the encrypted password.</returns>
protected string GenerateQueryStringPassword(string url)
{
var uri = new Uri(url);
var hmacshA1 = new HMACSHA1(Encoding.ASCII.GetBytes(Key.ToLowerInvariant()));
hmacshA1.Initialize();
var str = Convert.ToBase64String(hmacshA1.ComputeHash(Encoding.ASCII.GetBytes(uri.PathAndQuery)));
return(Uri.EscapeDataString(string.Format("HMAC{{{0}}}", str.ToLowerInvariant())));
}
private string ComputeHash(string privateKey, string message)
{
var key = Encoding.UTF8.GetBytes(privateKey);
using (var hmac = new HMACSHA1(key))
{
hmac.Initialize();
var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(message));
return(Convert.ToBase64String(hash));
}
}
private static string GetBase64Digest(string signatureString, string secretKey)
{
var enc = Encoding.UTF8;
var hmac = new HMACSHA1(enc.GetBytes(secretKey));
hmac.Initialize();
var buffer = enc.GetBytes(signatureString);
return(Convert.ToBase64String(hmac.ComputeHash(buffer)));
}
private static string Base64EncodeHash(Stream ms)
{
ms.Seek(0, SeekOrigin.Begin);
byte[] result;
HMACSHA1 shaM = new HMACSHA1();
shaM.Key = new byte[1];
shaM.Initialize();
result = shaM.ComputeHash(ms);
string hash = System.Convert.ToBase64String(result);
return hash;
}
