static void EncodeFile(byte[] key, String sourceFile, string destFile)
{
// initialize keyed hash object
HMACSHA1 hms = new HMACSHA1(key);
// open filestreams to read in original file and write out coded file
using(FileStream inStream = new FileStream(sourceFile,FileMode.Open))
using (FileStream outStream = new FileStream(destFile, FileMode.Create))
{
// array to hold keyed hash value of original file
byte[] hashValue = hms.ComputeHash(inStream);
// reset instream ready to read original file contents from start
inStream.Position = 0;
// write keyed hash value to coded file
outStream.Write(hashValue, 0, hashValue.Length);
// copy data from original file to output file, 1K at a time
int bytesRead;
byte[] buffer = new byte[1024];
do
{
bytesRead = inStream.Read(buffer, 0, 1024);
outStream.Write(buffer, 0, bytesRead);
} while (bytesRead > 0);
hms.Clear();
inStream.Close();
outStream.Close();
}
}
public static byte[] ComputeCombinedKey(byte[] requestorEntropy, byte[] issuerEntropy, int keySizeInBits)
{
if (requestorEntropy == null)
{
throw new ArgumentNullException("requestorEntropy");
}
if (issuerEntropy == null)
{
throw new ArgumentNullException("issuerEntropy");
}
int num = ValidateKeySizeInBytes(keySizeInBits);
byte[] array = new byte[num];
using (KeyedHashAlgorithm algorithm = new HMACSHA1())
{
algorithm.Key = requestorEntropy;
byte[] buffer = issuerEntropy;
byte[] buffer3 = new byte[(algorithm.HashSize / 8) + buffer.Length];
byte[] buffer4 = null;
try
{
try
{
int num2 = 0;
while (num2 < num)
{
algorithm.Initialize();
buffer = algorithm.ComputeHash(buffer);
buffer.CopyTo(buffer3, 0);
issuerEntropy.CopyTo(buffer3, buffer.Length);
algorithm.Initialize();
buffer4 = algorithm.ComputeHash(buffer3);
for (int i = 0; i < buffer4.Length; i++)
{
if (num2 >= num)
{
continue;
}
array[num2++] = buffer4[i];
}
}
}
catch
{
Array.Clear(array, 0, array.Length);
throw;
}
return array;
}
finally
{
if (buffer4 != null)
{
Array.Clear(buffer4, 0, buffer4.Length);
}
Array.Clear(buffer3, 0, buffer3.Length);
algorithm.Clear();
}
}
}
protected override void Dispose(bool disposing)
{
Array.Clear(_buffer, 0, _buffer.Length);
Array.Clear(_salt, 0, _salt.Length);
_hmac.Clear();
base.Dispose(disposing);
}
public string ComputeSignature(string signatureBase, string consumerSecret, string tokenSecret)
{
using (HMACSHA1 crypto = new HMACSHA1()) {
string key = Rfc3986.Encode(consumerSecret) + "&" + Rfc3986.Encode(tokenSecret);
crypto.Key = Encoding.ASCII.GetBytes(key);
string hash = Convert.ToBase64String(crypto.ComputeHash(Encoding.ASCII.GetBytes(signatureBase)));
crypto.Clear();
return hash;
}
}
private string GetHashString(string sPassword, string salt)
{
HashAlgorithm hash = new System.Security.Cryptography.HMACSHA1(Encoding.UTF8.GetBytes(salt));
byte[] hashBytes = hash.ComputeHash(Encoding.UTF8.GetBytes(sPassword));
hash.Clear();
return(BitConverter.ToString(hashBytes).Replace("-", string.Empty).ToLower());
}
public byte[] doFinal()
{
//return mac.doFinal();
cs.Close();
byte[] result = mentalis_mac.Hash;
byte[] key = mentalis_mac.Key;
mentalis_mac.Clear();
init(key);
return(result);
}
public byte[] doFinal()
{
//Console.WriteLine("Sha1");
//return mac.doFinal();
cs.Close();
byte[] result = mentalis_mac.Hash;
byte[] key = mentalis_mac.Key;
mentalis_mac.Clear();
init(key);
return(result);
}
public static byte[] Encriptar(string strTexto, byte[] objKey)
{
HMACSHA1 _objHMACSHA = new HMACSHA1(objKey);
try
{
return _objHMACSHA.ComputeHash(Encoding.UTF8.GetBytes(strTexto));
}
finally
{
_objHMACSHA.Clear();
}
}
public new void Dispose()
{
if (!m_Disposed)
{
m_Disposed = true;
m_md5.Clear();
m_sha1.Clear();
Array.Clear(m_s1, 0, m_s1.Length);
Array.Clear(m_s2, 0, m_s2.Length);
Array.Clear(m_ls, 0, m_ls.Length);
}
}
private bool Verify(int version, string privateMac, string privateHash,
string passphrase, string keyTypeName, string encryptionName, string comment, byte[] publicBlob, byte[] privateBlob)
{
byte[] macData;
using (MemoryStream macDataBuff = new MemoryStream())
{
if (version == 1)
{
WriteMacData(macDataBuff, privateBlob);
}
else
{
WriteMacData(macDataBuff, keyTypeName);
WriteMacData(macDataBuff, encryptionName);
WriteMacData(macDataBuff, comment);
WriteMacData(macDataBuff, publicBlob);
WriteMacData(macDataBuff, privateBlob);
}
macDataBuff.Close();
macData = macDataBuff.ToArray();
}
if (privateMac != null)
{
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] a = Encoding.ASCII.GetBytes("putty-private-key-file-mac-key");
sha1.TransformBlock(a, 0, a.Length, null, 0);
byte[] b = Encoding.UTF8.GetBytes(passphrase);
sha1.TransformFinalBlock(b, 0, b.Length);
byte[] key = sha1.Hash;
sha1.Clear();
System.Security.Cryptography.HMACSHA1 hmacsha1 = new System.Security.Cryptography.HMACSHA1(key);
byte[] hash = hmacsha1.ComputeHash(macData);
hmacsha1.Clear();
string mac = BinToHex(hash);
return(mac == privateMac);
}
else if (privateHash != null)
{
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] hash = sha1.ComputeHash(macData);
sha1.Clear();
string mac = BinToHex(hash);
return(mac == privateHash);
}
else
{
return(true);
}
}
public static string GetExpiringHMAC(string message, DateTime expiryDate)
{
HMAC alg = new HMACSHA1(Key);
try
{
string input = expiryDate.Ticks + message;
byte[] hashBytes = alg.ComputeHash(Encoding.UTF8.GetBytes(input));
byte[] result = new byte[8 + hashBytes.Length];
hashBytes.CopyTo(result, 8);
BitConverter.GetBytes(expiryDate.Ticks).CopyTo(result, 0);
return Swap(Convert.ToBase64String(result), "+=/", "-_,");
}
finally { alg.Clear(); }
}
/// <summary>
/// Get the Cart Signature used in the "signature"
/// form field that is posted to Google Checkout.
/// </summary>
/// <param name="cart">The Cart Xml returned from the
/// <see cref="GCheckout.Checkout.CheckoutShoppingCartRequest.GetXml"/>
/// method.</param>
/// <param name="merchantKey">Your Google Merchant Key</param>
/// <returns>A Base64 encoded string of the cart signature</returns>
public static string GetCartSignature(byte[] cart, string merchantKey)
{
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
byte[] key = encoding.GetBytes(merchantKey);
using (System.Security.Cryptography.HMACSHA1 cryptobj = new
System.Security.Cryptography.HMACSHA1(key)) {
string retVal =
System.Convert.ToBase64String(cryptobj.ComputeHash(cart));
cryptobj.Clear();
return(retVal);
}
}
/// <summary>
/// Authenticate packet and return authentication parameters value to the caller
/// </summary>
/// <param name="authenticationSecret">User authentication secret</param>
/// <param name="engineId">SNMP agent authoritative engine id</param>
/// <param name="wholeMessage">Message to authenticate</param>
/// <returns>Authentication parameters value</returns>
public byte[] authenticate(byte[] authenticationSecret, byte[] engineId, byte[] wholeMessage)
{
byte[] result = new byte[12];
byte[] authKey = PasswordToKey(authenticationSecret, engineId);
HMACSHA1 sha = new HMACSHA1(authKey);
byte[] hash = sha.ComputeHash(wholeMessage);
// copy 12 bytes of the hash into the wholeMessage
for (int i = 0; i < 12; i++)
{
result[i] = hash[i];
}
sha.Clear(); // release resources
return result;
}
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";
}
private byte[] computeSignature(String baseString)
{
byte[] _key;
lock (this)
{
if (key == null)
{
String keyString = Rfc3986.Encode(getConsumerSecret())
+ "&" + Rfc3986.Encode(getTokenSecret());
key = Encoding.GetEncoding(ENCODING).GetBytes(keyString);
}
_key = key;
}
using (HMACSHA1 crypto = new HMACSHA1())
{
crypto.Key = _key;
byte[] hash = crypto.ComputeHash(Encoding.GetEncoding(ENCODING).GetBytes(baseString));
crypto.Clear();
return hash;
}
}
/// <summary>
/// Generate a TOTP using provided binary data.
/// </summary>
/// <param name="key">Binary data.</param>
/// <returns>Time-based One Time Password encoded byte array.</returns>
public byte[] Generate(byte[] key)
{
System.Security.Cryptography.HMACSHA1 hmac = new System.Security.Cryptography.HMACSHA1(key, true); //Instanciates a new hash provider with a key.
byte[] hash = hmac.ComputeHash(GetBytes((ulong)Counter)); //Generates hash from key using counter.
hmac.Clear(); //Clear hash instance securing the key.
/*int binary = //Math.
* ((hash[offset] & 0x7f) << 24) //Math.
| ((hash[offset + 1] & 0xff) << 16) //Math.
| ((hash[offset + 2] & 0xff) << 8) //Math.
| (hash[offset + 3] & 0xff); //Math.
|
| int password = binary % (int)Math.Pow(10, length); //Math.*/
int offset = hash[hash.Length - 1] & 0x0f; //Math.
byte[] totp = { hash[offset + 3], hash[offset + 2], hash[offset + 1], hash[offset] };
return(totp);
/*
* return password.ToString(new string('0', length)); //Math.*/
}
/// <summary>
/// Generate a TOTP using provided binary data.
/// </summary>
/// <param name="key">Binary data.</param>
/// <returns>Time-based One Time Password encoded byte array.</returns>
public byte[] Generate(byte[] key)
{
System.Security.Cryptography.HMACSHA1 hmac = new System.Security.Cryptography.HMACSHA1(key, true); //Instanciates a new hash provider with a key.
byte[] hash = hmac.ComputeHash(GetBytes((ulong)Counter)); //Generates hash from key using counter.
hmac.Clear(); //Clear hash instance securing the key.
/*int binary = //Math.
((hash[offset] & 0x7f) << 24) //Math.
| ((hash[offset + 1] & 0xff) << 16) //Math.
| ((hash[offset + 2] & 0xff) << 8) //Math.
| (hash[offset + 3] & 0xff); //Math.
int password = binary % (int)Math.Pow(10, length); //Math.*/
int offset = hash[hash.Length - 1] & 0x0f; //Math.
byte[] totp = { hash[offset + 3], hash[offset + 2], hash[offset + 1], hash[offset] };
return totp;
/*
return password.ToString(new string('0', length)); //Math.*/
}
public override int GetHashCode()
{
HMACSHA1 hmac = new HMACSHA1(this.Secret);
CryptoStream cs = new CryptoStream(Stream.Null, hmac,
CryptoStreamMode.Write);
byte[] hbytes = ASCIIEncoding.ASCII.GetBytes(this.handle);
cs.Write(hbytes, 0, hbytes.Length);
cs.Close();
byte[] hash = hmac.Hash;
hmac.Clear();
long val = 0;
for (long i = 0; i < hash.Length; i++)
val ^= hash[i];
val ^= this.Expires.ToFileTimeUtc();
return (int)val;
}
/// <summary>
/// Returns the hash code.
/// </summary>
/// <returns>
/// A hash code for the current <see cref="T:System.Object"/>.
/// </returns>
public override int GetHashCode() {
HMACSHA1 hmac = new HMACSHA1(this.SecretKey);
try {
CryptoStream cs = new CryptoStream(Stream.Null, hmac, CryptoStreamMode.Write);
byte[] hbytes = ASCIIEncoding.ASCII.GetBytes(this.Handle);
cs.Write(hbytes, 0, hbytes.Length);
cs.Close();
byte[] hash = hmac.Hash;
hmac.Clear();
long val = 0;
for (int i = 0; i < hash.Length; i++) {
val = val ^ (long)hash[i];
}
val = val ^ this.Expires.ToFileTimeUtc();
return (int)val;
} finally {
((IDisposable)hmac).Dispose();
}
}
private bool Verify(int version, string privateMac, string privateHash,
string passphrase, string keyTypeName, string encryptionName, string comment, byte[] publicBlob, byte[] privateBlob)
{
byte[] macData;
using (MemoryStream macDataBuff = new MemoryStream()) {
if (version == 1) {
WriteMacData(macDataBuff, privateBlob);
}
else {
WriteMacData(macDataBuff, keyTypeName);
WriteMacData(macDataBuff, encryptionName);
WriteMacData(macDataBuff, comment);
WriteMacData(macDataBuff, publicBlob);
WriteMacData(macDataBuff, privateBlob);
}
macDataBuff.Close();
macData = macDataBuff.ToArray();
}
if (privateMac != null) {
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] a = Encoding.ASCII.GetBytes("putty-private-key-file-mac-key");
sha1.TransformBlock(a, 0, a.Length, null, 0);
byte[] b = Encoding.UTF8.GetBytes(passphrase);
sha1.TransformFinalBlock(b, 0, b.Length);
byte[] key = sha1.Hash;
sha1.Clear();
System.Security.Cryptography.HMACSHA1 hmacsha1 = new System.Security.Cryptography.HMACSHA1(key);
byte[] hash = hmacsha1.ComputeHash(macData);
hmacsha1.Clear();
string mac = BinToHex(hash);
return mac == privateMac;
}
else if (privateHash != null) {
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] hash = sha1.ComputeHash(macData);
sha1.Clear();
string mac = BinToHex(hash);
return mac == privateHash;
}
else {
return true;
}
}
/// <summary>
/// Computes the hash.
/// </summary>
/// <param name="version">The version.</param>
/// <param name="header">The header.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="data">The scope bytes.</param>
/// <param name="privacy">The privacy provider.</param>
/// <param name="length">The length bytes.</param>
/// <returns></returns>
public OctetString ComputeHash(VersionCode version, ISegment header, SecurityParameters parameters, ISnmpData data, IPrivacyProvider privacy, byte[] length)
{
if (header == null)
{
throw new ArgumentNullException("header");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (data == null)
{
throw new ArgumentNullException("data");
}
if (privacy == null)
{
throw new ArgumentNullException("privacy");
}
var key = PasswordToKey(_password, parameters.EngineId.GetRaw());
using (var sha1 = new HMACSHA1(key))
{
var hash = sha1.ComputeHash(ByteTool.PackMessage(length, version, header, parameters, data).ToBytes());
sha1.Clear();
var result = new byte[DigestLength];
Buffer.BlockCopy(hash, 0, result, 0, result.Length);
return new OctetString(result);
}
}
private byte[] Sign(NameValueCollection l)
{
byte[] data = KVUtil.SeqToKV(l, false);
HMACSHA1 hmac = new HMACSHA1(this.Secret);
byte[] hash = hmac.ComputeHash(data);
hmac.Clear();
return hash;
}
private string GetPolicyBase64(string key, string redirectTo, string contentType, string contentDisposition,
long maxUploadSize, out string sign)
{
var policyBuilder = new StringBuilder();
policyBuilder.AppendFormat("{{\"expiration\": \"{0}\",\"conditions\":[",
DateTime.UtcNow.AddMinutes(15).ToString(AWSSDKUtils.ISO8601DateFormat,
CultureInfo.InvariantCulture));
policyBuilder.AppendFormat("{{\"bucket\": \"{0}\"}},", _bucket);
policyBuilder.AppendFormat("[\"starts-with\", \"$key\", \"{0}\"],", key);
policyBuilder.Append("{\"acl\": \"public-read\"},");
if (!string.IsNullOrEmpty(redirectTo))
{
policyBuilder.AppendFormat("{{\"success_action_redirect\": \"{0}\"}},", redirectTo);
}
policyBuilder.AppendFormat("{{\"success_action_status\": \"{0}\"}},", 201);
if (!string.IsNullOrEmpty(contentType))
{
policyBuilder.AppendFormat("[\"eq\", \"$Content-Type\", \"{0}\"],", contentType);
}
if (!string.IsNullOrEmpty(contentDisposition))
{
policyBuilder.AppendFormat("[\"eq\", \"$Content-Disposition\", \"{0}\"],", contentDisposition);
}
policyBuilder.AppendFormat("[\"content-length-range\", 0, {0}]", maxUploadSize);
policyBuilder.Append("]}");
var policyBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(policyBuilder.ToString()));
//sign = AWSSDKUtils.HMACSign(policyBase64, _secretAccessKeyId, new HMACSHA1());
var algorithm = new HMACSHA1 { Key = Encoding.UTF8.GetBytes(_secretAccessKeyId) };
try
{
algorithm.Key = Encoding.UTF8.GetBytes(key);
sign = Convert.ToBase64String(algorithm.ComputeHash(Encoding.UTF8.GetBytes(policyBase64)));
}
finally
{
algorithm.Clear();
}
return policyBase64;
}
/// <summary>
/// Get the Cart Signature used in the "signature"
/// form field that is posted to Google Checkout.
/// </summary>
/// <param name="cart">The Cart Xml returned from the
/// <see cref="GCheckout.Checkout.CheckoutShoppingCartRequest.GetXml"/>
/// method.</param>
/// <param name="merchantKey">Your Google Merchant Key</param>
/// <returns>A Base64 encoded string of the cart signature</returns>
public static string GetCartSignature(byte[] cart, string merchantKey)
{
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
byte[] key = encoding.GetBytes(merchantKey);
using (System.Security.Cryptography.HMACSHA1 cryptobj = new
System.Security.Cryptography.HMACSHA1(key)) {
string retVal =
System.Convert.ToBase64String(cryptobj.ComputeHash(cart));
cryptobj.Clear();
return retVal;
}
}
/// <summary>
/// Verify SHA-1 authentication of a packet.
/// </summary>
/// <param name="authKey">Authentication key (not password)</param>
/// <param name="authenticationParameters">Authentication parameters extracted from the packet being authenticated</param>
/// <param name="wholeMessage">Entire packet being authenticated</param>
/// <returns>True on authentication success, otherwise false</returns>
public bool authenticateIncomingMsg(byte[] authKey, byte[] authenticationParameters, MutableByte wholeMessage)
{
HMACSHA1 sha = new HMACSHA1(authKey);
byte[] hash = sha.ComputeHash(wholeMessage);
MutableByte myhash = new MutableByte(hash, 12);
sha.Clear(); // release resources
if (myhash.Equals(authenticationParameters))
{
return true;
}
return false;
}
/// <summary>
/// Generate a TOTP using provided binary data.
/// </summary>
/// <param name="key">Binary data.</param>
/// <returns>Time-based One Time Password encoded byte array.</returns>
public string GenerateByByte(byte[] key)
{
HMACSHA1 hmac = new HMACSHA1(key, true); //Instanciates a new hash provider with a key.
byte[] codeInterval = BitConverter.GetBytes((ulong)Counter);
if (BitConverter.IsLittleEndian)
Array.Reverse(codeInterval);
byte[] hash = hmac.ComputeHash(codeInterval); //Generates hash from key using counter.
hmac.Clear(); //Clear hash instance securing the key.
int start = hash[hash.Length - 1] & 0xf;
byte[] totp = new byte[4];
Array.Copy(hash, start, totp, 0, 4);
if (BitConverter.IsLittleEndian)
Array.Reverse(totp);
return this.encoder(totp, length);
}
private byte[] GenerateResponse(byte[] challenge, byte[] key)
{
HMACSHA1 hmac = new HMACSHA1(key);
if (LT64)
challenge = challenge.Take(challengeLenBytes - 1).ToArray();
byte[] resp = hmac.ComputeHash(challenge);
hmac.Clear();
return resp;
}
