private async new Task <T> Request <T>(object param, OBS.Runtime.Internal.IRequest request) where T : new()
{
try
{
var clientWrapper = new RestClientWrapper(request, _disConfig);
string result = await clientWrapper.RequestAsync(param, _credentials.GetAccessKeyId(), _credentials.GetSecretKey(), _region, _disConfig.GetProjectId());
int statusCode = int.Parse(result.Split('\n')[0]);
var task = new TaskCompletionSource <T>();
if (statusCode >= 200 && statusCode < 300)
{
result = result.Substring(statusCode.ToString().Length + 1);
result = result.Equals("Created") ? "{\"status_code\":\"201 Created\",\"content\":\"\"}"
: (result.Equals("NoContent") ? "{\"status_code\":\"204 NO CONTENT\",\"content\":\"\"}"
: result);
task.SetResult(JsonConvert.DeserializeObject <T>(result));
return(task.Task.Result);
}
else
{
throw new Exception(result);
}
}
catch (Exception e)
{
throw;
}
}
private static void SignHttps(IRequest request, ClientConfig clientConfig, RequestMetrics metrics, string awsAccessKeyId, string awsSecretAccessKey)
{
string nonce = Guid.NewGuid().ToString();
string date = AWSSDKUtils.FormattedCurrentTimestampRFC822;
string stringToSign;
stringToSign = date + nonce;
metrics.AddProperty(Metric.StringToSign, stringToSign);
string signature = ComputeHash(stringToSign, awsSecretAccessKey, clientConfig.SignatureMethod);
StringBuilder builder = new StringBuilder();
builder.Append(HTTPS_SCHEME).Append(" ");
builder.Append("AWSAccessKeyId=" + awsAccessKeyId + ",");
builder.Append("Algorithm=" + clientConfig.SignatureMethod.ToString() + ",");
builder.Append("SignedHeaders=x-amz-date;x-amz-nonce,");
builder.Append("Signature=" + signature);
builder.Append(GetSignedHeadersComponent(request) + ",");
request.Headers[HeaderKeys.XAmzAuthorizationHeader] = builder.ToString();
request.Headers[HeaderKeys.XAmzNonceHeader] = nonce;
request.Headers[HeaderKeys.XAmzDateHeader] = date;
}
public override void Sign(IRequest request, string awsAccessKeyId, string awsSecretAccessKey)
{
//请求指标
var metrics = new RequestMetrics();
SignerRequestParamsEx signerParams = new SignerRequestParamsEx(request, this.regionName, this.serviceName, "SDK-HMAC-SHA256");
SignHttp(request, metrics, awsAccessKeyId, awsSecretAccessKey, signerParams);
}
private static void SignHttpEx(IRequest request, RequestMetrics metrics, string awsAccessKeyId,
string awsSecretAccessKey, SignerRequestParamsEx param = null)
{
string date = "20171006T170510Z"; //AWSSDKUtils.FormattedCurrentTimestampISO8601;
string hostHeader = request.Endpoint.Host;
request.Headers[HttpHeaderKeys.HostHeader] = hostHeader;
request.Headers[HttpHeaderKeys.SdkData] = date;
}
private long GetSigningDate(IRequest request)
{
DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1, 0, 0, 0));
var timeSpan = DateTime.Now.AddHours(-8) - startTime;
//var jj = ;
//long milliseconds = kk.Ticks / TimeSpan.TicksPerMillisecond;
return((long)timeSpan.TotalMilliseconds - (long)(request.TimeOffset * 1000));
}
private static string GetRequestPayload(IRequest request)
{
if (request.Content == null)
{
return(string.Empty);
}
Encoding encoding = Encoding.GetEncoding(DEFAULT_ENCODING);
return(encoding.GetString(request.Content, 0, request.Content.Length));
}
protected void AddHostHeader(IRequest request)
{
var endpoint = request.Endpoint;
var hostHeaderBuilder = new StringBuilder(endpoint.Host);
if (HttpUtils.IsUsingNonDefaultPort(endpoint))
{
hostHeaderBuilder.Append(":").Append(endpoint.Port);
}
request.Headers.Add("Host", hostHeaderBuilder.ToString());
}
private static string GetSignedHeadersComponent(IRequest request)
{
StringBuilder builder = new StringBuilder();
builder.Append("SignedHeaders=");
bool first = true;
foreach (string header in GetHeadersForStringToSign(request))
{
if (!first)
{
builder.Append(";");
}
builder.Append(header);
first = false;
}
return(builder.ToString());
}
private static bool IsHttpsRequest(IRequest request)
{
string protocol = request.Endpoint.Scheme;
if (protocol.Equals("http", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
else if (protocol.Equals("https", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
else
{
throw new ObsServiceException(
"Unknown request endpoint protocol encountered while signing request: " + protocol);
}
}
public override void Sign(IRequest request, ICredentials credentials)
{
var sanitizedCredentials = this.SanitizeCredentials(credentials);
var signerParams = new SignerRequestParamsEx(request, this.regionName, this.serviceName, "SDK-HMAC-SHA256");
this.AddHostHeader(request);
request.Headers.Add("X-Sdk-Date", signerParams.GetFormattedSigningDateTime());
String contentSha256 = this.CalculateContentHash(request);
if ("required".Equals(request.Headers["x-sdk-content-sha256"]))
{
request.Headers.Add("x-sdk-content-sha256", contentSha256);
}
var metrics = new RequestMetrics();
SignHttp(request, metrics, sanitizedCredentials.GetAccessKeyId(), sanitizedCredentials.GetSecretKey(), signerParams);
}
private static List <string> GetHeadersForStringToSign(IRequest request)
{
List <string> headersToSign = new List <string>();
foreach (var entry in request.Headers)
{
string key = entry.Key;
if (key.StartsWith("x-sdk-date", StringComparison.OrdinalIgnoreCase) ||
key.Equals("content-type", StringComparison.OrdinalIgnoreCase) ||
key.Equals("x-sdk-version", StringComparison.OrdinalIgnoreCase) ||
key.Equals("accept", StringComparison.OrdinalIgnoreCase) ||
key.Equals("host", StringComparison.OrdinalIgnoreCase))
{
headersToSign.Add(key.ToLower());
}
}
headersToSign.Sort(StringComparer.OrdinalIgnoreCase);
return(headersToSign);
}
/// <summary>
/// Signs the specified request with the AWS3 signing protocol by using the
/// AWS account credentials given in the method parameters.
/// </summary>
/// <param name="awsAccessKeyId">The AWS public key</param>
/// <param name="awsSecretAccessKey">The AWS secret key used to sign the request in clear text</param>
/// <param name="metrics">Request metrics</param>
/// <param name="clientConfig">The configuration that specifies which hashing algorithm to use</param>
/// <param name="request">The request to have the signature compute for</param>
/// <exception cref="OBS.Runtime.SignatureException">If any problems are encountered while signing the request</exception>
public override void Sign(IRequest request, ClientConfig clientConfig, RequestMetrics metrics, string awsAccessKeyId, string awsSecretAccessKey)
{
var signer = SelectSigner(request, clientConfig);
var useV4 = signer is AWS4Signer;
if (useV4)
{
signer.Sign(request, clientConfig, metrics, awsAccessKeyId, awsSecretAccessKey);
}
else
{
if (UseAws3Https)
{
SignHttps(request, clientConfig, metrics, awsAccessKeyId, awsSecretAccessKey);
}
else
{
SignHttp(request, metrics, awsAccessKeyId, awsSecretAccessKey);
}
}
}
public SignerRequestParams(IRequest <T> request, string regionNameOverride, string serviceNameOverride, string signingAlgorithm, string signDate)
{
if (request == null)
{
throw new ArgumentException("Request cannot be null");
}
if (signingAlgorithm == null)
{
throw new ArgumentException("Signing Algorithm cannot be null");
}
this._signingDateTimeMilli = null == signDate?this.GetSigningDate(request) : this.GetSigningDate(signDate);
this._request = request;
this._formattedSigningDate = SignerUtils.FormatDateStamp(this._signingDateTimeMilli);
this._serviceName = serviceNameOverride ?? "";
this._regionName = regionNameOverride ?? "";
this._scope = this.GenerateScope(this._formattedSigningDate, this._serviceName, this._regionName);
this._formattedSigningDateTime = SignerUtils.FormatTimestamp(this._signingDateTimeMilli);
this._signingAlgorithm = signingAlgorithm;
}
private static string GetCanonicalizedHeadersForStringToSign(IRequest request)
{
List <string> headersToSign = GetHeadersForStringToSign(request);
for (int i = 0; i < headersToSign.Count; i++)
{
headersToSign[i] = headersToSign[i].ToLower(CultureInfo.InvariantCulture);
}
SortedDictionary <string, string> sortedHeaderMap = new SortedDictionary <string, string>();
foreach (var entry in request.Headers)
{
if (headersToSign.Contains(entry.Key.ToLower(CultureInfo.InvariantCulture)))
{
sortedHeaderMap[entry.Key] = entry.Value;
}
}
StringBuilder builder = new StringBuilder();
foreach (var entry in sortedHeaderMap)
{
string value = entry.Value;
string key = entry.Key.ToLower(CultureInfo.InvariantCulture);
if (key.Equals("x-sdk-date"))
{
value = "20171006T170510Z";
}
builder.Append(key);
builder.Append(":");
builder.Append(value);
builder.Append("\n");
}
return(builder.ToString());
}
public SignerRequestParams(IRequest <T> request, string regionNameOverride, string serviceNameOverride, string signingAlgorithm) :
this(request, regionNameOverride, serviceNameOverride, signingAlgorithm, null)
{
}
private static void SignHttp(IRequest request, RequestMetrics metrics, string awsAccessKeyId, string awsSecretAccessKey, SignerRequestParamsEx param = null)
{
string hostHeader = request.Endpoint.Host;
request.Headers[HttpHeaderKeys.HostHeader] = hostHeader;
SigningAlgorithm algorithm = SigningAlgorithm.HmacSHA256;
string nonce = Guid.NewGuid().ToString();
string date = AWSSDKUtils.FormattedCurrentTimestampISO8601;
bool isHttps = IsHttpsRequest(request);
// Temporarily disabling the AWS3 HTTPS signing scheme and only using AWS3 HTTP
isHttps = false;
request.Headers[HttpHeaderKeys.SdkData] = date;
// AWS3 HTTP requires that we sign the Host header
// so we have to have it in the request by the time we sign.
if (!request.Endpoint.IsDefaultPort)
{
hostHeader += ":" + request.Endpoint.Port;
}
byte[] bytesToSign = null;
string stringToSign;
Uri url = request.Endpoint;
if (!string.IsNullOrEmpty(request.ResourcePath))
{
url = new Uri(request.Endpoint, request.ResourcePath);
}
stringToSign = request.HttpMethod + "\n"
+ GetCanonicalizedResourcePath(url) + "\n"
+ GetCanonicalizedQueryString(request.Parameters) + "\n"
+ GetCanonicalizedHeadersForStringToSign(request) + "\n"
+ GetRequestPayload(request);
String hehehe = CreateStringToSign(stringToSign, param);
bytesToSign = CryptoUtilFactory.CryptoInstance.ComputeSHA256Hash(Encoding.UTF8.GetBytes(hehehe));
metrics.AddProperty(Metric.StringToSign, stringToSign);
string signature = AWSSDKUtils.ToHex(ComputeHash(bytesToSign, awsSecretAccessKey, algorithm, true), true);
//this.ComputeSignature()
StringBuilder builder = new StringBuilder();
builder.Append("SDK-HMAC-SHA256");
builder.Append(" ");
builder.Append("Credential=" + awsAccessKeyId + "/20171006/cn-north-1/dis/sdk_request, ");
//builder.Append("Algorithm=" + algorithm.ToString() + ",");
builder.Append(GetSignedHeadersComponent(request) + ",");
builder.Append("Signature=" + signature);
string authorizationHeader = builder.ToString();
request.Headers[HttpHeaderKeys.Authorization] = authorizationHeader;
}
private long GetSigningDate(IRequest <T> request)
{
return(DateTime.Now.Millisecond - (long)(request.GetTimeOffset() * 1000));
}
protected String CalculateContentHash(IRequest request)
{
return(request.ComputeContentStreamHash());
}
