Create Message on Amazon SQS with WinRT

gistfile1.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using NUnit.Framework;
using Windows.Security.Cryptography;
using Windows.Security.Cryptography.Core;
using Windows.Storage.Streams;

namespace NewAwsTest
{
    [TestFixture]
    public class SampleTestClass
    {
        [Test]
        public void Create_Message()
        {
            var client = new HttpClient();
            var timeStamp = DateTime.UtcNow;

            var amazonId = "*****";
            var amazonSecret = "*****";

            var content = new List<KeyValuePair<string, string>>
            {
                new KeyValuePair<string, string>("Action", "SendMessage"),
                new KeyValuePair<string, string>("AWSAccessKeyId", amazonId),
                new KeyValuePair<string, string>("DelaySeconds", "0"),
                new KeyValuePair<string, string>("MessageBody", "Bananas are awesome"),
                new KeyValuePair<string, string>("SignatureMethod", "HmacSHA256"),
                new KeyValuePair<string, string>("SignatureVersion", "4"),
                new KeyValuePair<string, string>("Timestamp", timeStamp.ToString("yyyy-MM-dd\\THH:mm:ss.fff\\Z")),
                new KeyValuePair<string, string>("Version", "2012-11-05")
            };
            
            Debug.WriteLine("---CARNONICAL");
            
            var createPayload = CreatePayload(content);

            Debug.WriteLine(createPayload);
            Debug.WriteLine("------");

            var hashedPayload = HashPayload(createPayload);

            Debug.WriteLine(hashedPayload);
            Debug.WriteLine("------");

            var createCarnonical = CreateCarnonical(timeStamp.ToString("yyyyMMddTHHmmssZ"), hashedPayload);

            Debug.WriteLine(createCarnonical);
            Debug.WriteLine("------");

            var hashedCarnonical = HashCarnonical(createCarnonical);

            Debug.WriteLine(hashedCarnonical);
            Debug.WriteLine("------");


            Debug.WriteLine("---STRING TO SIGN");

            var stringToSign = new StringBuilder();

            stringToSign.Append("AWS4-HMAC-SHA256\n");
            stringToSign.Append(timeStamp.ToString("yyyyMMddTHHmmssZ") + "\n");
            stringToSign.Append(timeStamp.ToString("yyyyMMdd") + "/us-east-1/sqs/aws4_request\n");
            stringToSign.Append(hashedCarnonical);

            Debug.WriteLine(stringToSign.ToString());
            Debug.WriteLine("------");

            Debug.WriteLine("---SIGNING KEY");
            var signingKey = CreateSigningKey("AWS4" + amazonSecret,
                                              timeStamp.ToString("yyyyMMdd"), "us-east-1", "sqs", "aws4_request");

            Debug.WriteLine(signingKey);
            Debug.WriteLine("------");

            var signature = CreateSignature(signingKey, stringToSign.ToString());


            Debug.WriteLine(signature);
            Debug.WriteLine("------");

            const string authFormat = "Credential={0}/{1}/us-east-1/sqs/aws4_request, SignedHeaders=host;user-agent;x-amz-date, Signature={2}";

            var auth = string.Format(authFormat, amazonId, timeStamp.ToString("yyyyMMdd"), signature);

            var request = new FormUrlEncodedContent(content);

            client.DefaultRequestHeaders.Add("User-Agent", "aws-sdk-dotnet/1.5.14.0 .NET Runtime/4.0 .NET Framework/4.0 OS/6.2.9200.0");
            client.DefaultRequestHeaders.Add("Host", "sqs.us-east-1.amazonaws.com");
            client.DefaultRequestHeaders.Add("X-Amz-Date", timeStamp.ToString("yyyyMMddTHHmmssZ"));
            client.DefaultRequestHeaders.ExpectContinue = false;
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("AWS4-HMAC-SHA256", auth);

            var result = client.PostAsync("https://sqs.us-east-1.amazonaws.com/916865987663/PhillipTestQueue", request);

            result.Wait();

            Assert.NotNull(result.Result);
        }

        private string HashCarnonical(string createCarnonical)
        {
            var signed = ComputeHash(createCarnonical);

            return CryptographicBuffer.EncodeToHexString(signed);
        }

        private string CreateCarnonical(string toString, string hashedPayload)
        {
            var stringBuilder = new StringBuilder();

            stringBuilder.Append("POST\n");
            stringBuilder.Append("/916865987663/PhillipTestQueue\n");
            stringBuilder.Append("\n");
            stringBuilder.Append("host:sqs.us-east-1.amazonaws.com\n");
            stringBuilder.Append("user-agent:aws-sdk-dotnet/1.5.14.0 .NET Runtime/4.0 .NET Framework/4.0 OS/6.2.9200.0\n");
            stringBuilder.Append("x-amz-date:" + toString + "\n");
            stringBuilder.Append("\n");
            stringBuilder.Append("host;user-agent;x-amz-date\n");
            stringBuilder.Append(hashedPayload);

            return stringBuilder.ToString();
        }

        private string HashPayload(string createPayload)
        {
            var signed = ComputeHash(createPayload);

            return CryptographicBuffer.EncodeToHexString(signed);
        }

        private string CreatePayload(IEnumerable<KeyValuePair<string, string>> content)
        {
            return string.Join("&", content.Select(x => x.Key + "=" + System.Net.WebUtility.UrlEncode(x.Value)));
        }
        
        private string CreateSignature(IBuffer signingKey, string stringToSign)
        {
            var macAlgorithmProvider = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha256.ToUpper());

            var encodedStringToSign = CryptographicBuffer.ConvertStringToBinary(stringToSign, BinaryStringEncoding.Utf8);

            var key = macAlgorithmProvider.CreateKey(signingKey);
            var signedSignature = CryptographicEngine.Sign(key, encodedStringToSign);

            return CryptographicBuffer.EncodeToHexString(signedSignature);
        }

        private IBuffer CreateSigningKey(string kSecret, string date, string region, string service, string terminator)
        {
            var binaryKsecret = CryptographicBuffer.ConvertStringToBinary(kSecret, BinaryStringEncoding.Utf8);

            var hashDate = ComputerHash(binaryKsecret, date);
            var hashRegion = ComputerHash(hashDate, region);
            var hashService = ComputerHash(hashRegion, service);
            var hashTerminator = ComputerHash(hashService, terminator);

            return hashTerminator;
        }

        private IBuffer ComputeHash(string contents)
        {
            var algorithm = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
            var encodedBuffer = CryptographicBuffer.ConvertStringToBinary(contents, BinaryStringEncoding.Utf8);

            var hashed = algorithm.HashData(encodedBuffer);

            return hashed;
        }

        private IBuffer ComputerHash(IBuffer key, string value)
        {
            var macAlgorithmProvider = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha256.ToUpper());
            var binaryValue = CryptographicBuffer.ConvertStringToBinary(value, BinaryStringEncoding.Utf8);

            return CryptographicEngine.Sign(macAlgorithmProvider.CreateKey(key), binaryValue);
        }
    }
}