private Dictionary <string, object> GetHttpHeaders(string endpoint, string payload, string access_token, string secret_key)
{
var _signature = "";
var _secretKey = Encoding.UTF8.GetBytes(secret_key.ToUpper());
using (var _hmac = new HMACSHA512(_secretKey))
{
_hmac.Initialize();
var _bytes = Encoding.UTF8.GetBytes(payload);
var _rawHmac = _hmac.ComputeHash(_bytes);
_signature = BytesToHex(_rawHmac);
}
var _headers = new Dictionary <string, object>();
{
_headers.Add("X-COINONE-PAYLOAD", payload);
_headers.Add("X-COINONE-SIGNATURE", _signature);
}
return(_headers);
}
private Dictionary <string, object> GetHttpHeaders(string endpoint, Dictionary <string, object> rgData, string apiKey, string apiSecret)
{
var _nonce = CUnixTime.NowMilli.ToString();
var _data = EncodeURIComponent(rgData);
var _message = String.Format("{0};{1};{2}", endpoint, _data, _nonce);
var _secretKey = Encoding.UTF8.GetBytes(apiSecret);
var _hmac = new HMACSHA512(_secretKey);
_hmac.Initialize();
var _bytes = Encoding.UTF8.GetBytes(_message);
var _rawHmac = _hmac.ComputeHash(_bytes);
var _encoded = EncodeHex(_rawHmac);
var _signature = Convert.ToBase64String(_encoded);
var _headers = new Dictionary <string, object>();
{
_headers.Add("Api-Key", apiKey);
_headers.Add("Api-Sign", _signature);
_headers.Add("Api-Nonce", _nonce);
}
return(_headers);
}
/// <summary>
/// NetAESEncryption constructor
/// </summary>
public NetAESEncryption(string key, int bitsize)
{
if (!s_keysizes.Contains(bitsize))
{
throw new NetException(string.Format("Not a valid key size. (Valid values are: {0})", NetUtility.MakeCommaDelimitedList(s_keysizes)));
}
byte[] entropy = Encoding.UTF32.GetBytes(key);
// I know hardcoding salts is bad, but in this case I think it is acceptable.
HMACSHA512 hmacsha512 = new HMACSHA512(Convert.FromBase64String("i88NEiez3c50bHqr3YGasDc4p8jRrxJAaiRiqixpvp4XNAStP5YNoC2fXnWkURtkha6M8yY901Gj07IRVIRyGL=="));
hmacsha512.Initialize();
for (int i = 0; i < 1000; i++)
{
entropy = hmacsha512.ComputeHash(entropy);
}
int keylen = bitsize / 8;
m_key = new byte[keylen];
Buffer.BlockCopy(entropy, 0, m_key, 0, keylen);
m_iv = new byte[s_blocksizes[0] / 8];
Buffer.BlockCopy(entropy, entropy.Length - m_iv.Length - 1, m_iv, 0, m_iv.Length);
m_bitSize = bitsize;
}
/// <summary>
/// NetTriplsDESEncryption constructor
/// </summary>
public NetTripleDESEncryption(string key, int bitsize)
{
if (!m_keysizes.Contains(bitsize))
{
string lengths = m_keysizes.Aggregate("", (current, i) => current + string.Format("{0}, ", i));
lengths = lengths.Remove(lengths.Length - 3);
throw new NetException(string.Format("Not a valid key size. (Valid values are: {0})", lengths));
}
byte[] entropy = Encoding.UTF32.GetBytes(key);
// I know hardcoding salts is bad, but in this case I think it is acceptable.
HMACSHA512 hmacsha512 = new HMACSHA512(Convert.FromBase64String("i88NEiez3c50bHqr3YGasDc4p8jRrxJAaiRiqixpvp4XNAStP5YNoC2fXnWkURtkha6M8yY901Gj07IRVIRyGL=="));
hmacsha512.Initialize();
for (int i = 0; i < 1000; i++)
{
entropy = hmacsha512.ComputeHash(entropy);
}
int keylen = bitsize / 8;
m_key = new byte[keylen];
Buffer.BlockCopy(entropy, 0, m_key, 0, keylen);
m_iv = new byte[m_blocksizes[0] / 8];
Buffer.BlockCopy(entropy, entropy.Length - m_iv.Length - 1, m_iv, 0, m_iv.Length);
m_bitSize = bitsize;
}
public string SingData(string signatureString)
{
hmac.Initialize();
byte[] buffer = Encoding.UTF8.GetBytes(signatureString);
return(BitConverter.ToString(hmac.ComputeHash(buffer)).Replace("-", "").ToLower());
}
public byte[] Hash(byte[] clearBytes)
{
using (var hmac = new HMACSHA512(_key))
{
hmac.Initialize();
byte[] hashBytes = hmac.ComputeHash(clearBytes);
return(hashBytes);
}
}
public static string SingRestData(string secretKey, string signatureString)
{
var enc = Encoding.UTF8;
HMACSHA512 hmac = new HMACSHA512(enc.GetBytes(secretKey));
hmac.Initialize();
byte[] buffer = enc.GetBytes(signatureString);
return(BitConverter.ToString(hmac.ComputeHash(buffer)).Replace("-", "").ToLower());
}
private byte[] HmacSha512(byte[] key, params byte[][] authenticateMe)
{
using var ms = new MemoryStream();
using var hmacSha512 = new HMACSHA512(key);
hmacSha512.Initialize();
foreach (var bytes in authenticateMe)
{
ms.Write(bytes);
}
return(hmacSha512.ComputeHash(ms.ToArray()));
}
private string StringToHmacSHA512(string queryString)
{
using (var hmac = new HMACSHA512())
{
hmac.Key = _key;
hmac.Initialize();
var buffer = Encoding.ASCII.GetBytes(queryString);
var signatureBytes = hmac.ComputeHash(buffer);
var signature = Convert.ToBase64String(signatureBytes);
return(signature);
}
}
public static string HMACSHA512(string input, string key)
{
byte[] secrectKey = Encoding.UTF8.GetBytes(key);
using (HMACSHA512 hmac = new HMACSHA512(secrectKey))
{
hmac.Initialize();
byte[] bytes_hmac_in = Encoding.UTF8.GetBytes(input);
byte[] bytes_hamc_out = hmac.ComputeHash(bytes_hmac_in);
string str_hamc_out = BitConverter.ToString(bytes_hamc_out);
str_hamc_out = str_hamc_out.Replace("-", "");
return(str_hamc_out);
}
}
public static StringBuilder AppendSignature(this StringBuilder builder, string key)
{
using (var hmac = new HMACSHA512())
{
hmac.Key = Convert.FromBase64String(key);
hmac.Initialize();
var buffer = Encoding.ASCII.GetBytes(builder.ToString());
var signatureBytes = hmac.ComputeHash(buffer);
builder.Append($"&Signature={HttpUtility.UrlEncode(Convert.ToBase64String(signatureBytes))}");
return(builder);
}
}
public static HdKey GetMasterKeyFromSeed(ReadOnlySpan <byte> seed)
{
var key = Encoding.UTF8.GetBytes(Ed25519Curve).ToList();
using var hash = new HMACSHA512(key.ToArray());
hash.Initialize();
hash.ComputeHash(seed.ToArray());
var i = hash.Hash.AsSpan();
return(new HdKey
{
Key = i.Slice(0, 32).ToArray(),
ChainCode = i.Slice(32).ToArray()
});
}
private string CalculateDigest(string applicationId, string secret, string token)
{
// The hmac salt is the concatenation of application ID and secret to eliminate the use of lookup table for brute force attacks.
string salt = applicationId + secret;
byte[] secretKeyBArr = Encoding.UTF8.GetBytes(salt);
byte[] tokenBArr = Encoding.UTF8.GetBytes(token);
HMACSHA512 hmacsha512 = new HMACSHA512(secretKeyBArr);
hmacsha512.Initialize();
byte[] final = hmacsha512.ComputeHash(tokenBArr);
return(Convert.ToBase64String(final, Base64FormattingOptions.None));
}
public static string HashPassword(string secret, string password)
{
using var hmac = new HMACSHA512
{
Key = Encoding.UTF8.GetBytes(secret)
};
hmac.Initialize();
var pwdHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(password));
var sb = new StringBuilder();
foreach (var b in pwdHash)
{
sb.Append(b.ToString("X"));
}
return(sb.ToString());
}
public static Object hash_hmac(string signatureString, string secretKey, bool raw_output = false)
{
var enc = Encoding.UTF8;
HMACSHA512 hmac = new HMACSHA512(enc.GetBytes(secretKey));
hmac.Initialize();
byte[] buffer = enc.GetBytes(signatureString);
if (raw_output)
{
return(hmac.ComputeHash(buffer));
}
else
{
return(BitConverter.ToString(hmac.ComputeHash(buffer)).Replace("-", "").ToLower());
}
}
/// <summary>
/// HMAC_SHA512
/// </summary>
/// <param name="srcString">The string to be encrypted</param>
/// <param name="key">encrypte key</param>
/// <returns></returns>
public static string HMACSHA512(string srcString, string key)
{
Check.Argument.IsNotEmpty(srcString, nameof(srcString));
Check.Argument.IsNotEmpty(key, nameof(key));
byte[] secrectKey = Encoding.UTF8.GetBytes(key);
using (HMACSHA512 hmac = new HMACSHA512(secrectKey))
{
hmac.Initialize();
byte[] bytes_hmac_in = Encoding.UTF8.GetBytes(srcString);
byte[] bytes_hamc_out = hmac.ComputeHash(bytes_hmac_in);
string str_hamc_out = BitConverter.ToString(bytes_hamc_out);
str_hamc_out = str_hamc_out.Replace("-", "");
return(str_hamc_out);
}
}
public override void Initialize()
{
aesNonce = new byte[12];
aesKey = new byte[32];
RandomNumberGenerator.Fill(aesNonce);
RandomNumberGenerator.Fill(aesKey);
var tasks = new Task[options.Threads];
for (var i = 0; i < options.Threads; i++)
{
var i1 = i;
tasks[i1] = Task.Run(() =>
{
var data = Encoding.UTF8.GetBytes(DataGenerator.GenerateString((int)(volume / options.Threads)));
var rand = new Random();
sha512Key = new byte[64];
for (var j = 0; j < 64; j++)
{
sha512Key[j] = (byte)rand.Next();
}
var hmac = new HMACSHA512(sha512Key);
hmac.Initialize();
datasSHA[i1] = Encoding.Default.GetString(hmac.ComputeHash(data));
datasAES[i1] = new byte[data.Length];
using var aes = new AesGcm(aesKey);
aesTag[i1] = new byte[16];
aes.Encrypt(aesNonce, data, datasAES[i1], aesTag[i1]);
});
}
Task.WaitAll(tasks);
GC.Collect();
}
/// <summary>
/// HMAC_SHA512
/// </summary>
/// <param name="source">The string to be encrypted</param>
/// <param name="key">encrypte key</param>
/// <returns></returns>
public static string A512(string source, string key)
{
if (string.IsNullOrEmpty(source))
{
throw new ArgumentNullException(nameof(source), "");
}
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException(nameof(key), "");
}
using (var hmac = new HMACSHA512(Encoding.UTF8.GetBytes(key)))
{
hmac.Initialize();
var strHmacOut = BitConverter.ToString(hmac.ComputeHash(Encoding.UTF8.GetBytes(source)));
strHmacOut = strHmacOut.Replace("-", "");
return(strHmacOut);
}
}
