public static void Main (string[] args)
		{
			var host = "https://api.coinbase.com/";
			var apiKey = "yourApiKey";
			var apiSecret = "youApiSecret";

			var unixTimestamp = (Int32)(DateTime.UtcNow.Subtract (new DateTime (1970, 1, 1))).TotalSeconds;
			var currency = "USD";
			var message = string.Format ("{0}GET/v2/prices/spot?currency={1}", unixTimestamp.ToString (), currency);

			byte[] secretKey = Encoding.UTF8.GetBytes (apiSecret);
			HMACSHA256 hmac = new HMACSHA256 (secretKey);
			hmac.Initialize ();
			byte[] bytes = Encoding.UTF8.GetBytes (message);
			byte[] rawHmac = hmac.ComputeHash (bytes);
			var signature = rawHmac.ByteArrayToHexString ();

			var price = host
				.AppendPathSegment ("v2/prices/spot")
				.SetQueryParam ("currency", currency)
				.WithHeader ("CB-ACCESS-SIGN", signature)
				.WithHeader ("CB-ACCESS-TIMESTAMP", unixTimestamp)
				.WithHeader ("CB-ACCESS-KEY", apiKey)
				.GetJsonAsync<dynamic> ()
				.Result;

			Console.WriteLine (price.ToString (Formatting.None));
			Console.ReadLine ();
		}

        private static byte[] PHash(byte[] secret, byte[] seed, int iterations)
        {
            using (HMACSHA256 hmac = new HMACSHA256(secret))
            {
                byte[][] a = new byte[iterations + 1][];

                a[0] = seed;

                for (int i = 0; i < iterations; i++)
                {
                    a[i + 1] = hmac.ComputeHash(a[i]);
                }

                byte[] prf = new byte[iterations * 32];

                byte[] buffer = new byte[32 + seed.Length];
                Buffer.BlockCopy(seed, 0, buffer, 32, seed.Length);

                for (int i = 0; i < iterations; i++)
                {
                    Buffer.BlockCopy(a[i + 1], 0, buffer, 0, 32);

                    byte[] hash = hmac.ComputeHash(buffer);

                    Buffer.BlockCopy(hash, 0, prf, 32 * i, 32);
                }

                return prf;
            }
        }

        public static string BuildBase64Signature(
                string apiKey,
                string appId,
                Uri rawUri,
                HttpMethod httpMethod,
                HttpContent content,
                string nonce,
                string requestTimeStamp
            )
        {
            var requestUri = HttpUtility.UrlEncode(rawUri.AbsoluteUri.ToLower());
            var requestHttpMethod = httpMethod.Method;

            // Get the content string out of the content.
            string requestContentBase64String = ComputeBase64RequestContent(content);

            // Rebuild the signature raw data.
            var signatureRawData =
            $"{appId}{requestHttpMethod}{requestUri}{requestTimeStamp}{nonce}{requestContentBase64String}";

            // Get the api key bytes.
            var secretKeyBytes = Convert.FromBase64String(apiKey);

            // Get the signature.
            var signature = Encoding.UTF8.GetBytes(signatureRawData);

            // Create HMAC SHA class with key data.
            using (var hmac = new HMACSHA256(secretKeyBytes))
            {
                return Convert.ToBase64String(hmac.ComputeHash(signature));
            }
        }

        /// <summary>
        /// Encrypt a message using AES in CBC (cipher-block chaining) mode.
        /// </summary>
        /// <param name="plaintext">The message (plaintext) to encrypt</param>
        /// <param name="key">An AES key</param>
        /// <param name="iv">The IV to use or null to use a 0 IV</param>
        /// <param name="addHmac">When set, a SHA256-based HMAC (HMAC256) of 32 bytes using the same key is added to the plaintext
        /// before it is encrypted.</param>
        /// <returns>The ciphertext derived by encrypting the orignal message using AES in CBC mode</returns>
        public static byte[] EncryptAesCbc(byte[] plaintext, byte[] key, byte[] iv = null, bool addHmac = false)
        {
            using (Aes aes =Aes.Create())
//            using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider())
            {
                aes.Key = key;
                if (iv == null)
                    iv = NullIv;
                aes.Mode = CipherMode.CBC;
                aes.IV = iv;

                // Encrypt the message with the key using CBC and InitializationVector=0
                byte[] cipherText;
                using (System.IO.MemoryStream ciphertext = new System.IO.MemoryStream())
                {
                    using (CryptoStream cs = new CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(plaintext, 0, plaintext.Length);
                        if (addHmac)
                        {
                            byte[] hmac = new HMACSHA256(key).ComputeHash(plaintext);
                            cs.Write(hmac, 0, hmac.Length);
                        }
                        cs.Flush();
                    }
                    cipherText = ciphertext.ToArray();
                }

                return cipherText;
            }
        }

        public static string GenerateHMACSHA256AuthorisationToken(string sessionToken, string sharedSecret, out string dateString)
        {
            if (String.IsNullOrWhiteSpace(sharedSecret))
            {
                throw new ArgumentNullException("sharedSecret");
            }

            if (String.IsNullOrWhiteSpace(sessionToken))
            {
                throw new ArgumentNullException("sessionToken");
            }

            // Generate UTC ISO 8601 date string.
            dateString = DateTime.UtcNow.ToString("o");
            // 1. Combine the Token and current date time in UTC using ISO 8601 format.
            byte[] messageBytes = Encoding.ASCII.GetBytes(sessionToken + ":" + dateString);
            // 2. Calculate the HMAC SHA 256 using the Consumer Secret and then Base64 encode.
            byte[] keyBytes = Encoding.ASCII.GetBytes(sharedSecret);
            string hmacsha256EncodedString;

            using (HMACSHA256 hmacsha256 = new HMACSHA256(keyBytes))
            {
                byte[] hashMessage = hmacsha256.ComputeHash(messageBytes);
                hmacsha256EncodedString = Convert.ToBase64String(hashMessage);
            }

            // 3. Combine the Token with the resulting string from above separated by a colon.
            string combinedMessage = sessionToken + ":" + hmacsha256EncodedString;
            // 4. Base64 encode this string.
            string base64EncodedString = Convert.ToBase64String(Encoding.ASCII.GetBytes(combinedMessage));

            // 5. Prefix this string with the Authentication Method and a space.
            return AuthorisationMethod.HMACSHA256.ToString() + " " + base64EncodedString;
        }

 // Computes a keyed hash for a source file, creates a target file with the keyed hash
 // prepended to the contents of the source file, then decrypts the file and compares
 // the source and the decrypted files.
 public static void EncodeFile(byte[] key, String sourceFile, String destFile)
 {
     // Initialize the keyed hash object.
     HMACSHA256 myhmacsha256 = new HMACSHA256(key);
     FileStream inStream = new FileStream(sourceFile, FileMode.Open);
     FileStream outStream = new FileStream(destFile, FileMode.Create);
     // Compute the hash of the input file.
     byte[] hashValue = myhmacsha256.ComputeHash(inStream);
     // Reset inStream to the beginning of the file.
     inStream.Position = 0;
     // Write the computed hash value to the output file.
     outStream.Write(hashValue, 0, hashValue.Length);
     // Copy the contents of the sourceFile to the destFile.
     int bytesRead;
     // read 1K at a time
     byte[] buffer = new byte[1024];
     do
     {
         // Read from the wrapping CryptoStream.
         bytesRead = inStream.Read(buffer, 0, 1024);
         outStream.Write(buffer, 0, bytesRead);
     } while (bytesRead > 0);
     myhmacsha256.Clear();
     // Close the streams
     inStream.Close();
     outStream.Close();
     return;
 }

 static JsonWebToken()
 {
     HashAlgorithms = new Dictionary<JwtHashAlgorithm, Func<byte[], byte[], byte[]>>
                      {
                          {JwtHashAlgorithm.RS256, (key, value) =>
                                                   {
                                                       using (var sha = new HMACSHA256(key))
                                                       {
                                                           return sha.ComputeHash(value);
                                                       }
                                                   }
                          },
                          {JwtHashAlgorithm.HS384, (key, value) =>
                                                   {
                                                       using (var sha = new HMACSHA384(key))
                                                       {
                                                           return sha.ComputeHash(value);
                                                       }
                                                   }
                          },
                          {JwtHashAlgorithm.HS512, (key, value) =>
                                                   {
                                                       using (var sha = new HMACSHA512(key))
                                                       {
                                                           return sha.ComputeHash(value);
                                                       }
                                                   }
                          }
                      };
 }

        public static FacebookSignedRequestResult Verify(string appSecret, string signedRequest)
        {
            var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(appSecret));
            var javaScriptSerializer = new JavaScriptSerializer();

            if (string.IsNullOrEmpty(signedRequest) || !signedRequest.Contains("."))
            {
                return new FacebookSignedRequestResult(false, string.Empty, string.Empty, null, null);
            }

            var split = signedRequest.Split('.');
            var providedPayloadHash = split[0];
            var requestPayload = split[1];

            byte[] hashBytes = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(requestPayload));
            string calculatedHash = Convert.ToBase64String(hashBytes);
            string modifiedBase64Hash = ConvertToModifiedBase64(calculatedHash);

            string payloadBase64 = ConvertFromModifiedBase64(requestPayload);
            byte[] payloadBytes = Convert.FromBase64String(payloadBase64);
            string payloadJson = Encoding.UTF8.GetString(payloadBytes);

            var request = javaScriptSerializer.Deserialize<FacebookSignedRequest>(payloadJson);

            return new FacebookSignedRequestResult(providedPayloadHash == modifiedBase64Hash, request.user_id, request.app_data, request.page, request.user);
        }

 /// <summary>
 /// Every time is created new instance of class to guarantee thread safety
 /// </summary>
 /// <param name="function"></param>
 /// <returns></returns>
 private HMAC GetAlgorithmByFunctionName(string function)
 {
     HMAC a;
     switch(Util.Convertion.EnumNameToValue<HMACFunction>(function))
     {
         case HMACFunction.HMACMD5:
             a = new HMACMD5();
             break;
         case HMACFunction.HMACSHA1:
             a = new HMACSHA1();
             break;
         case HMACFunction.HMACSHA256:
             a = new HMACSHA256();
             break;
         case HMACFunction.HMACSHA384:
             a = new HMACSHA384();
             break;
         case HMACFunction.HMACSHA512:
             a = new HMACSHA512();
             break;
         default:
             throw new ArgumentException("Unknown function", "function");
     }
     return a;
 }

 public byte[] ComputeHmac(string input)
 {
     using (var hmac = new HMACSHA256(this.signingKey))
     {
         return hmac.ComputeHash(this.encoding.GetBytes(input));
     }
 }

        public static string AuthorizationHeader(
            string storageAccount, 
            string storageKey, 
            string method, 
            DateTime now,
            HttpRequestMessage request, 
            string ifMatch = "", 
            string contentMD5 = "", 
            string size = "", 
            string contentType = "")
        {
            string stringToSign = string.Format(
                "{0}\n\n\n{1}\n{5}\n{6}\n\n\n{2}\n\n\n\n{3}{4}", 
                method, 
                (size == string.Empty) ? string.Empty : size, 
                ifMatch, 
                GetCanonicalizedHeaders(request), 
                GetCanonicalizedResource(request.RequestUri, storageAccount), 
                contentMD5, 
                contentType);

            byte[] signatureBytes = Encoding.UTF8.GetBytes(stringToSign);
            string authorizationHeader;
            using (HMACSHA256 hmacsha256 = new HMACSHA256(Convert.FromBase64String(storageKey)))
            {
                authorizationHeader = "SharedKey " + storageAccount + ":"
                                      + Convert.ToBase64String(hmacsha256.ComputeHash(signatureBytes));
            }

            return authorizationHeader;
        }

 public byte[] ComputeHmac(byte[] sessionKey, byte[] encrpytedData)
 {
     using (var hmac = new HMACSHA256(sessionKey))
     {
         return hmac.ComputeHash(encrpytedData);
     }
 }

 public static string CreateToken(string message, string key)
 {
     var myhmacsha1 = new HMACSHA256(Encoding.ASCII.GetBytes(key));
     var byteArray = Encoding.ASCII.GetBytes(message);
     var stream = new MemoryStream(byteArray);
     return myhmacsha1.ComputeHash(stream).Aggregate("", (s, e) => s + $"{e:x2}", s => s);
 }

        bool m_isCheckAmazonAwsInstancesEmailWasSent = false;  // to avoid sending the same warning email many times; send only once

        //# Key derivation functions. See: 
        //# http://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-python
        internal byte[] sign(byte[] key, string msg)
        {
            HMACSHA256 hmac = new HMACSHA256(key);
            var computedDigest = hmac.ComputeHash(Encoding.UTF8.GetBytes(msg));
            return computedDigest;
            //return hmac.new(key, msg.encode('utf-8'), hashlib.sha256).digest();
        }

 /// <summary>
 /// Computes the <see cref="HMACSHA256"/> hash of the string using the given
 /// salt and <c cref="Encoding.UTF8">UTF8 Encoding</c>
 /// </summary>
 /// <param name="plainText"></param>
 /// <param name="salt"></param>
 /// <returns></returns>
 public static byte[] ComputeHash(this string plainText, string salt)
 {
     var encoding = Encoding.UTF8;
     using (var sha = new HMACSHA256(Encoding.UTF8.GetBytes(salt))) {
         return sha.ComputeHash(encoding.GetBytes(plainText));
     }
 }

 /// <summary>
 ///  Generates the private key for a specific domain, based on the master key. 
 /// </summary>
 /// <returns>
 ///  The private key. 
 /// </returns>
 /// <param name='masterKey'>
 ///  The master key. 
 /// </param>
 /// <param name='domain'>
 ///  The domain. 
 /// </param>
 public byte[] GeneratePrivateKey(byte[] masterKey, string domain)
 {
     using(HMACSHA256 hmac = new HMACSHA256(masterKey))
     {
         return hmac.ComputeHash(Encoding.UTF8.GetBytes(domain));
     }
 }

 // Decrypt the encoded file and compare to original file.
 public static bool DecodeFile(byte[] key, String sourceFile)
 {
     // Initialize the keyed hash object.
     HMACSHA256 hmacsha256 = new HMACSHA256(key);
     // Create an array to hold the keyed hash value read from the file.
     byte[] storedHash = new byte[hmacsha256.HashSize / 8];
     // Create a FileStream for the source file.
     FileStream inStream = new FileStream(sourceFile, FileMode.Open);
     // Read in the storedHash.
     inStream.Read(storedHash, 0, storedHash.Length);
     // Compute the hash of the remaining contents of the file.
     // The stream is properly positioned at the beginning of the content,
     // immediately after the stored hash value.
     byte[] computedHash = hmacsha256.ComputeHash(inStream);
     // compare the computed hash with the stored value
     for (int i = 0; i < storedHash.Length; i++)
     {
         if (computedHash[i] != storedHash[i])
         {
             Console.WriteLine("Hash values differ! Encoded file has been tampered with!");
             return false;
         }
     }
     Console.WriteLine("Hash values agree -- no tampering occurred.");
     return true;
 }

 public static byte[] HMACSHA256(byte[] key, byte[] data)
 {
     using (var hmac = new HMACSHA256(key))
     {
         return hmac.ComputeHash(data);
     }
 }

 static byte[] hmacSHA256(String data, String key)
 {
     using (HMACSHA256 hmac = new HMACSHA256(Encoding.ASCII.GetBytes(key)))
     {
         return hmac.ComputeHash(Encoding.ASCII.GetBytes(data));
     }
 }

		protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
		{
			string requestContentBase64String = string.Empty;
			string requestUri = System.Web.HttpUtility.UrlEncode(request.RequestUri.AbsoluteUri.ToLower());

			//Checking if the request contains body, usually will be null wiht HTTP GET
			if (request.Content != null)
			{
				using (var md5 = MD5.Create())
				{
					var content = await request.Content.ReadAsByteArrayAsync();
				
					//Hashing the request body, any change in request body will result in different hash, we'll incure message integrity
					var requestContentHash = md5.ComputeHash(content);
					requestContentBase64String = Convert.ToBase64String(requestContentHash);
				}
			}

			//create random nonce for each request
			var nonce = Guid.NewGuid().ToString("N");

			//Creating the raw signature string
			var signatureRawData = string.Concat(_apiKey, "POST", requestUri, nonce, requestContentBase64String);	
			var secretKeyByteArray = Convert.FromBase64String(_apiSecret);
			var signature = Encoding.UTF8.GetBytes(signatureRawData);
			using (var hmac = new HMACSHA256(secretKeyByteArray))
			{
				var signatureBytes = hmac.ComputeHash(signature);
				var requestSignatureBase64String = Convert.ToBase64String(signatureBytes);

				//Setting the values in the Authorization header using custom scheme (amx)
				request.Headers.Authorization = new AuthenticationHeaderValue("amx", string.Format("{0}:{1}:{2}", _apiKey, requestSignatureBase64String, nonce));
			}
			return await base.SendAsync(request, cancellationToken);
		}