Как сделать недействительной кэшированную конечную точку шлюза AWS API в ASPNETCORE? - PullRequest
Новая
       8

Как сделать недействительной кэшированную конечную точку шлюза AWS API в ASPNETCORE?

0 голосов
/ 19 декабря 2018

[Примечание: я уже разработал ответ на этот вопрос, но изо всех сил пытался найти что-нибудь в Интернете, поэтому я добавляю это здесь]

Мне нужно сделать недействительным кэш для отдельной конечной точки шлюза API AWS, используяASPNETCORE.

В документах говорится, что нужно отправить подписанный запрос.Как вы делаете это в .NET?

1 Ответ

0 голосов
/ 19 декабря 2018

Я отвечаю на свой вопрос, так как не мог найти много информации в Интернете, и потребовалось немного времени, чтобы начать работать.Надеюсь, это кому-нибудь поможет.

Я добавил код здесь: https://gist.github.com/secretorange/905b4811300d7c96c71fa9c6d115ee24

CacheInvalidationRequestBuilder.cs 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;

namespace Aws
{
    public static class CacheInvalidationRequestBuilder
    {
        private const string ServiceName    = "execute-api";
        private const string Algorithm      = "AWS4-HMAC-SHA256";
        private const string ContentType    = "application/json";
        private const string DateTimeFormat = "yyyyMMddTHHmmssZ";
        private const string DateFormat     = "yyyyMMdd";

        public static WebRequest Build(CacheInvalidationRequestModel request)
        {
            string hashedRequestPayload = CreateRequestPayload(String.Empty);

            string authorization = Sign(request, hashedRequestPayload, "GET", request.AbsolutePath, request.QueryString);
            string requestDate = DateTime.UtcNow.ToString(DateTimeFormat);

            var webRequest = WebRequest.Create($"https://{request.Host}{request.AbsolutePath}");

            webRequest.Method = "GET";
            webRequest.ContentType = ContentType;

            webRequest.Headers.Add("Cache-Control", "max-age=0");
            webRequest.Headers.Add("Host", request.Host);
            webRequest.Headers.Add("X-Amz-Date", requestDate);

            webRequest.Headers.Add("Authorization", authorization);

            return webRequest;
        }

        private static string CreateRequestPayload(string jsonString)
        {
            return HexEncode(Hash(ToBytes(jsonString)));
        }

        private static string Sign(CacheInvalidationRequestModel request, string hashedRequestPayload, string requestMethod, string canonicalUri, string canonicalQueryString)
        {
            var currentDateTime = DateTime.UtcNow;

            var dateStamp = currentDateTime.ToString(DateFormat);
            var requestDate = currentDateTime.ToString(DateTimeFormat);
            var credentialScope = $"{dateStamp}/{request.Region}/{ServiceName}/aws4_request";

            var headers = new SortedDictionary<string, string> {
                { "cache-control", "max-age=0" },
                { "content-type", ContentType },
                { "host", request.Host },
                { "x-amz-date", requestDate }
            };

            var canonicalHeaders = string.Join("\n", headers.Select(x => x.Key.ToLowerInvariant() + ":" + x.Value.Trim())) + "\n";

            // Task 1: Create a Canonical Request For Signature Version 4
            var SignedHeaders = String.Join(';', headers.Select(x => x.Key.ToLowerInvariant()));

            var canonicalRequest = $"{requestMethod}\n{canonicalUri}\n{canonicalQueryString}\n{canonicalHeaders}\n{SignedHeaders}\n{hashedRequestPayload}";

            var hashedCanonicalRequest = HexEncode(Hash(ToBytes(canonicalRequest)));

            // Task 2: Create a String to Sign for Signature Version 4
            var stringToSign = $"{Algorithm}\n{requestDate}\n{credentialScope}\n{hashedCanonicalRequest}";

            // Task 3: Calculate the AWS Signature Version 4
            var signingKey = GetSignatureKey(request.SecretKey, dateStamp, request.Region, ServiceName);
            var signature = HexEncode(HmacSha256(stringToSign, signingKey));

            // Task 4: Prepare a signed request
            // Authorization: algorithm Credential=access key ID/credential scope, SignedHeadaers=SignedHeaders, Signature=signature
            var authorization = $"{Algorithm} Credential={request.AccessKey}/{dateStamp}/{request.Region}/{ServiceName}/aws4_request, SignedHeaders={SignedHeaders}, Signature={signature}";

            return authorization;
        }

        private static byte[] GetSignatureKey(string key, string dateStamp, string regionName, string serviceName)
        {
            var kDate = HmacSha256(dateStamp, ToBytes("AWS4" + key));
            var kRegion = HmacSha256(regionName, kDate);
            var kService = HmacSha256(serviceName, kRegion);
            return HmacSha256("aws4_request", kService);
        }

        private static byte[] ToBytes(string str)
        {
            return Encoding.UTF8.GetBytes(str.ToCharArray());
        }

        private static string HexEncode(byte[] bytes)
        {
            return BitConverter.ToString(bytes).Replace("-", string.Empty).ToLowerInvariant();
        }

        private static byte[] Hash(byte[] bytes)
        {
            return SHA256.Create().ComputeHash(bytes);
        }

        private static byte[] HmacSha256(string data, byte[] key)
        {
            return new HMACSHA256(key).ComputeHash(ToBytes(data));
        }
    }
}

CacheInvalidationRequestModel.cs 

using System;
using System.Collections.Generic;
using System.Text;

namespace Aws
{
    public class CacheInvalidationRequestModel
    {
        public string Region { get; set; }

        public string Host { get; set; }

        public string AbsolutePath { get; set; }

        public string QueryString { get; set; }

        public string AccessKey { get; set; }

        public string SecretKey { get; set; }
    }
}

Как использовать код

Чтобы сделать запрос, используйте код, подобный следующему: 

var url = $"/myendpoint";

var model = GetCacheInvalidationRequestModel(url);

var request = CacheInvalidationRequestBuilder.Build(model);

try
{
  // Hit the endpoint
  using (var response = request.GetResponse())
  {
    // Not currently doing anything with the response
  }
}
catch(Exception ex)
{
  Logger.LogError(ex, "Problem invalidating cache for url: " + url);
}

Метод GetCacheInvalidationRequestModel может выглядеть примерно так (я передаю в свойствах моделиas IOptions): 

private CacheInvalidationRequestModel GetCacheInvalidationRequestModel(string absolutePath)
{
    return new CacheInvalidationRequestModel()
    {
        Region = Options.Region,
        Host = Options.Host,
        AccessKey = Options.InvalidatorKey,
        SecretKey = Options.InvalidatorSecret,
        AbsolutePath = absolutePath
    };
}

Информация AWS

Документы AWS для создания подписанных запросов находятся здесь: https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html

Вашему пользователю AWS потребуется прикрепленная политика,как показано здесь: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-caching.html

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "execute-api:InvalidateCache"
      ],
      "Resource": [
        "arn:aws:execute-api:region:account-id:api-id/stage-name/GET/resource-path-specifier"
      ]
    }
  ]
}

ПРИМЕЧАНИЕ. Вы можете использовать подстановочные знаки, если хотите.

...