29c4aa00a1
Handle canonical headers and signed headers creation as explained here: https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html The algo tells that signed and canonical must contain at last host and x-amz-date. So we check whatever thoses are present in the curl http headers list. If they are, we use the one enter by curl user, otherwise we generate them. then we to lower, and remove space from each http headers plus host and x-amz-date, then sort them all by alphabetical order. This patch also fix a bug with host header, which was ignoring the port. Closes #7966
525 lines
15 KiB
C
525 lines
15 KiB
C
/***************************************************************************
|
|
* _ _ ____ _
|
|
* Project ___| | | | _ \| |
|
|
* / __| | | | |_) | |
|
|
* | (__| |_| | _ <| |___
|
|
* \___|\___/|_| \_\_____|
|
|
*
|
|
* Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
|
|
*
|
|
* This software is licensed as described in the file COPYING, which
|
|
* you should have received as part of this distribution. The terms
|
|
* are also available at https://curl.haxx.se/docs/copyright.html.
|
|
*
|
|
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|
* copies of the Software, and permit persons to whom the Software is
|
|
* furnished to do so, under the terms of the COPYING file.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
* SPDX-License-Identifier: curl
|
|
*
|
|
***************************************************************************/
|
|
|
|
#include "curl_setup.h"
|
|
|
|
#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_CRYPTO_AUTH)
|
|
|
|
#include "urldata.h"
|
|
#include "strcase.h"
|
|
#include "strdup.h"
|
|
#include "http_aws_sigv4.h"
|
|
#include "curl_sha256.h"
|
|
#include "transfer.h"
|
|
|
|
#include "strcase.h"
|
|
#include "parsedate.h"
|
|
#include "sendf.h"
|
|
|
|
#include <time.h>
|
|
|
|
/* The last 3 #include files should be in this order */
|
|
#include "curl_printf.h"
|
|
#include "curl_memory.h"
|
|
#include "memdebug.h"
|
|
|
|
#include "slist.h"
|
|
|
|
#define HMAC_SHA256(k, kl, d, dl, o) \
|
|
do { \
|
|
ret = Curl_hmacit(Curl_HMAC_SHA256, \
|
|
(unsigned char *)k, \
|
|
(unsigned int)kl, \
|
|
(unsigned char *)d, \
|
|
(unsigned int)dl, o); \
|
|
if(ret) { \
|
|
goto fail; \
|
|
} \
|
|
} while(0)
|
|
|
|
#define TIMESTAMP_SIZE 17
|
|
|
|
static void sha256_to_hex(char *dst, unsigned char *sha, size_t dst_l)
|
|
{
|
|
int i;
|
|
|
|
DEBUGASSERT(dst_l >= 65);
|
|
for(i = 0; i < 32; ++i) {
|
|
msnprintf(dst + (i * 2), dst_l - (i * 2), "%02x", sha[i]);
|
|
}
|
|
}
|
|
|
|
static char *find_date_hdr(struct Curl_easy *data, const char *sig_hdr)
|
|
{
|
|
char *tmp = Curl_checkheaders(data, sig_hdr, strlen(sig_hdr));
|
|
|
|
if(tmp)
|
|
return tmp;
|
|
return Curl_checkheaders(data, STRCONST("Date"));
|
|
}
|
|
|
|
/* remove whitespace, and lowercase all headers */
|
|
static void trim_headers(struct curl_slist *head)
|
|
{
|
|
struct curl_slist *l;
|
|
for(l = head; l; l = l->next) {
|
|
char *value; /* to read from */
|
|
char *store;
|
|
size_t colon = strcspn(l->data, ":");
|
|
Curl_strntolower(l->data, l->data, colon);
|
|
|
|
value = &l->data[colon];
|
|
if(!*value)
|
|
continue;
|
|
++value;
|
|
store = value;
|
|
|
|
/* skip leading whitespace */
|
|
while(*value && ISBLANK(*value))
|
|
value++;
|
|
|
|
while(*value) {
|
|
int space = 0;
|
|
while(*value && ISBLANK(*value)) {
|
|
value++;
|
|
space++;
|
|
}
|
|
if(space) {
|
|
/* replace any number of consecutive whitespace with a single space,
|
|
unless at the end of the string, then nothing */
|
|
if(*value)
|
|
*store++ = ' ';
|
|
}
|
|
else
|
|
*store++ = *value++;
|
|
}
|
|
*store = 0; /* null terminate */
|
|
}
|
|
}
|
|
|
|
/* maximum lenth for the aws sivg4 parts */
|
|
#define MAX_SIGV4_LEN 64
|
|
#define MAX_SIGV4_LEN_TXT "64"
|
|
|
|
#define DATE_HDR_KEY_LEN (MAX_SIGV4_LEN + sizeof("X--Date"))
|
|
|
|
/* FQDN + host: */
|
|
#define FULL_HOST_LEN (255 + sizeof("host:"))
|
|
|
|
/* string been x-PROVIDER-date:TIMESTAMP, I need +1 for ':' */
|
|
#define DATE_FULL_HDR_LEN (DATE_HDR_KEY_LEN + TIMESTAMP_SIZE + 1)
|
|
|
|
/* timestamp should point to a buffer of at last TIMESTAMP_SIZE bytes */
|
|
static CURLcode make_headers(struct Curl_easy *data,
|
|
const char *hostname,
|
|
char *timestamp,
|
|
char *provider1,
|
|
char **date_header,
|
|
struct dynbuf *canonical_headers,
|
|
struct dynbuf *signed_headers)
|
|
{
|
|
char date_hdr_key[DATE_HDR_KEY_LEN];
|
|
char date_full_hdr[DATE_FULL_HDR_LEN];
|
|
struct curl_slist *head = NULL;
|
|
struct curl_slist *tmp_head = NULL;
|
|
CURLcode ret = CURLE_OUT_OF_MEMORY;
|
|
struct curl_slist *l;
|
|
int again = 1;
|
|
|
|
/* provider1 mid */
|
|
Curl_strntolower(provider1, provider1, strlen(provider1));
|
|
provider1[0] = Curl_raw_toupper(provider1[0]);
|
|
|
|
msnprintf(date_hdr_key, DATE_HDR_KEY_LEN, "X-%s-Date", provider1);
|
|
|
|
/* provider1 lowercase */
|
|
Curl_strntolower(provider1, provider1, 1); /* first byte only */
|
|
msnprintf(date_full_hdr, DATE_FULL_HDR_LEN,
|
|
"x-%s-date:%s", provider1, timestamp);
|
|
|
|
if(Curl_checkheaders(data, STRCONST("Host"))) {
|
|
head = NULL;
|
|
}
|
|
else {
|
|
char full_host[FULL_HOST_LEN];
|
|
|
|
if(data->state.aptr.host) {
|
|
size_t pos;
|
|
|
|
if(strlen(data->state.aptr.host) > FULL_HOST_LEN) {
|
|
ret = CURLE_URL_MALFORMAT;
|
|
goto fail;
|
|
}
|
|
strcpy(full_host, data->state.aptr.host);
|
|
/* remove /r/n as the separator for canonical request must be '\n' */
|
|
pos = strcspn(full_host, "\n\r");
|
|
full_host[pos] = 0;
|
|
}
|
|
else {
|
|
if(strlen(hostname) > FULL_HOST_LEN) {
|
|
ret = CURLE_URL_MALFORMAT;
|
|
goto fail;
|
|
}
|
|
msnprintf(full_host, FULL_HOST_LEN, "host:%s", hostname);
|
|
}
|
|
|
|
head = curl_slist_append(NULL, full_host);
|
|
if(!head)
|
|
goto fail;
|
|
}
|
|
|
|
|
|
for(l = data->set.headers; l; l = l->next) {
|
|
tmp_head = curl_slist_append(head, l->data);
|
|
if(!tmp_head)
|
|
goto fail;
|
|
head = tmp_head;
|
|
}
|
|
|
|
trim_headers(head);
|
|
|
|
*date_header = find_date_hdr(data, date_hdr_key);
|
|
if(!*date_header) {
|
|
tmp_head = curl_slist_append(head, date_full_hdr);
|
|
if(!tmp_head)
|
|
goto fail;
|
|
head = tmp_head;
|
|
*date_header = curl_maprintf("%s: %s", date_hdr_key, timestamp);
|
|
}
|
|
else {
|
|
char *value;
|
|
|
|
*date_header = strdup(*date_header);
|
|
if(!*date_header)
|
|
goto fail;
|
|
|
|
value = strchr(*date_header, ':');
|
|
if(!value)
|
|
goto fail;
|
|
++value;
|
|
while(ISBLANK(*value))
|
|
++value;
|
|
strncpy(timestamp, value, TIMESTAMP_SIZE - 1);
|
|
timestamp[TIMESTAMP_SIZE - 1] = 0;
|
|
}
|
|
|
|
/* alpha-sort in a case sensitive manner */
|
|
do {
|
|
again = 0;
|
|
for(l = head; l; l = l->next) {
|
|
struct curl_slist *next = l->next;
|
|
|
|
if(next && strcmp(l->data, next->data) > 0) {
|
|
char *tmp = l->data;
|
|
|
|
l->data = next->data;
|
|
next->data = tmp;
|
|
again = 1;
|
|
}
|
|
}
|
|
} while(again);
|
|
|
|
for(l = head; l; l = l->next) {
|
|
char *tmp;
|
|
|
|
if(Curl_dyn_add(canonical_headers, l->data))
|
|
goto fail;
|
|
if(Curl_dyn_add(canonical_headers, "\n"))
|
|
goto fail;
|
|
|
|
tmp = strchr(l->data, ':');
|
|
if(tmp)
|
|
*tmp = 0;
|
|
|
|
if(l != head) {
|
|
if(Curl_dyn_add(signed_headers, ";"))
|
|
goto fail;
|
|
}
|
|
if(Curl_dyn_add(signed_headers, l->data))
|
|
goto fail;
|
|
}
|
|
|
|
ret = CURLE_OK;
|
|
fail:
|
|
curl_slist_free_all(head);
|
|
|
|
return ret;
|
|
}
|
|
|
|
CURLcode Curl_output_aws_sigv4(struct Curl_easy *data, bool proxy)
|
|
{
|
|
CURLcode ret = CURLE_OUT_OF_MEMORY;
|
|
struct connectdata *conn = data->conn;
|
|
size_t len;
|
|
const char *arg;
|
|
char provider0[MAX_SIGV4_LEN + 1]="";
|
|
char provider1[MAX_SIGV4_LEN + 1]="";
|
|
char region[MAX_SIGV4_LEN + 1]="";
|
|
char service[MAX_SIGV4_LEN + 1]="";
|
|
const char *hostname = conn->host.name;
|
|
time_t clock;
|
|
struct tm tm;
|
|
char timestamp[TIMESTAMP_SIZE];
|
|
char date[9];
|
|
struct dynbuf canonical_headers;
|
|
struct dynbuf signed_headers;
|
|
char *date_header = NULL;
|
|
const char *post_data = data->set.postfields;
|
|
size_t post_data_len = 0;
|
|
unsigned char sha_hash[32];
|
|
char sha_hex[65];
|
|
char *canonical_request = NULL;
|
|
char *request_type = NULL;
|
|
char *credential_scope = NULL;
|
|
char *str_to_sign = NULL;
|
|
const char *user = data->state.aptr.user ? data->state.aptr.user : "";
|
|
char *secret = NULL;
|
|
unsigned char sign0[32] = {0};
|
|
unsigned char sign1[32] = {0};
|
|
char *auth_headers = NULL;
|
|
|
|
DEBUGASSERT(!proxy);
|
|
(void)proxy;
|
|
|
|
if(Curl_checkheaders(data, STRCONST("Authorization"))) {
|
|
/* Authorization already present, Bailing out */
|
|
return CURLE_OK;
|
|
}
|
|
|
|
/* we init thoses buffers here, so goto fail will free initialized dynbuf */
|
|
Curl_dyn_init(&canonical_headers, CURL_MAX_HTTP_HEADER);
|
|
Curl_dyn_init(&signed_headers, CURL_MAX_HTTP_HEADER);
|
|
|
|
/*
|
|
* Parameters parsing
|
|
* Google and Outscale use the same OSC or GOOG,
|
|
* but Amazon uses AWS and AMZ for header arguments.
|
|
* AWS is the default because most of non-amazon providers
|
|
* are still using aws:amz as a prefix.
|
|
*/
|
|
arg = data->set.str[STRING_AWS_SIGV4] ?
|
|
data->set.str[STRING_AWS_SIGV4] : "aws:amz";
|
|
|
|
/* provider1[:provider2[:region[:service]]]
|
|
|
|
No string can be longer than N bytes of non-whitespace
|
|
*/
|
|
(void)sscanf(arg, "%" MAX_SIGV4_LEN_TXT "[^:]"
|
|
":%" MAX_SIGV4_LEN_TXT "[^:]"
|
|
":%" MAX_SIGV4_LEN_TXT "[^:]"
|
|
":%" MAX_SIGV4_LEN_TXT "s",
|
|
provider0, provider1, region, service);
|
|
if(!provider0[0]) {
|
|
failf(data, "first provider can't be empty");
|
|
ret = CURLE_BAD_FUNCTION_ARGUMENT;
|
|
goto fail;
|
|
}
|
|
else if(!provider1[0])
|
|
strcpy(provider1, provider0);
|
|
|
|
if(!service[0]) {
|
|
char *hostdot = strchr(hostname, '.');
|
|
if(!hostdot) {
|
|
failf(data, "service missing in parameters and hostname");
|
|
ret = CURLE_URL_MALFORMAT;
|
|
goto fail;
|
|
}
|
|
len = hostdot - hostname;
|
|
if(len > MAX_SIGV4_LEN) {
|
|
failf(data, "service too long in hostname");
|
|
ret = CURLE_URL_MALFORMAT;
|
|
goto fail;
|
|
}
|
|
strncpy(service, hostname, len);
|
|
service[len] = '\0';
|
|
|
|
if(!region[0]) {
|
|
const char *reg = hostdot + 1;
|
|
const char *hostreg = strchr(reg, '.');
|
|
if(!hostreg) {
|
|
failf(data, "region missing in parameters and hostname");
|
|
ret = CURLE_URL_MALFORMAT;
|
|
goto fail;
|
|
}
|
|
len = hostreg - reg;
|
|
if(len > MAX_SIGV4_LEN) {
|
|
failf(data, "region too long in hostname");
|
|
ret = CURLE_URL_MALFORMAT;
|
|
goto fail;
|
|
}
|
|
strncpy(region, reg, len);
|
|
region[len] = '\0';
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUGBUILD
|
|
{
|
|
char *force_timestamp = getenv("CURL_FORCETIME");
|
|
if(force_timestamp)
|
|
clock = 0;
|
|
else
|
|
time(&clock);
|
|
}
|
|
#else
|
|
time(&clock);
|
|
#endif
|
|
ret = Curl_gmtime(clock, &tm);
|
|
if(ret) {
|
|
goto fail;
|
|
}
|
|
if(!strftime(timestamp, sizeof(timestamp), "%Y%m%dT%H%M%SZ", &tm)) {
|
|
ret = CURLE_OUT_OF_MEMORY;
|
|
goto fail;
|
|
}
|
|
|
|
ret = make_headers(data, hostname, timestamp, provider1,
|
|
&date_header, &canonical_headers, &signed_headers);
|
|
if(ret)
|
|
goto fail;
|
|
ret = CURLE_OUT_OF_MEMORY;
|
|
|
|
memcpy(date, timestamp, sizeof(date));
|
|
date[sizeof(date) - 1] = 0;
|
|
|
|
if(post_data) {
|
|
if(data->set.postfieldsize < 0)
|
|
post_data_len = strlen(post_data);
|
|
else
|
|
post_data_len = (size_t)data->set.postfieldsize;
|
|
}
|
|
if(Curl_sha256it(sha_hash, (const unsigned char *) post_data,
|
|
post_data_len))
|
|
goto fail;
|
|
|
|
sha256_to_hex(sha_hex, sha_hash, sizeof(sha_hex));
|
|
|
|
{
|
|
Curl_HttpReq httpreq;
|
|
const char *method;
|
|
|
|
Curl_http_method(data, conn, &method, &httpreq);
|
|
|
|
canonical_request =
|
|
curl_maprintf("%s\n" /* HTTPRequestMethod */
|
|
"%s\n" /* CanonicalURI */
|
|
"%s\n" /* CanonicalQueryString */
|
|
"%s\n" /* CanonicalHeaders */
|
|
"%s\n" /* SignedHeaders */
|
|
"%s", /* HashedRequestPayload in hex */
|
|
method,
|
|
data->state.up.path,
|
|
data->state.up.query ? data->state.up.query : "",
|
|
Curl_dyn_ptr(&canonical_headers),
|
|
Curl_dyn_ptr(&signed_headers),
|
|
sha_hex);
|
|
if(!canonical_request)
|
|
goto fail;
|
|
}
|
|
|
|
/* provider 0 lowercase */
|
|
Curl_strntolower(provider0, provider0, strlen(provider0));
|
|
request_type = curl_maprintf("%s4_request", provider0);
|
|
if(!request_type)
|
|
goto fail;
|
|
|
|
credential_scope = curl_maprintf("%s/%s/%s/%s",
|
|
date, region, service, request_type);
|
|
if(!credential_scope)
|
|
goto fail;
|
|
|
|
if(Curl_sha256it(sha_hash, (unsigned char *) canonical_request,
|
|
strlen(canonical_request)))
|
|
goto fail;
|
|
|
|
sha256_to_hex(sha_hex, sha_hash, sizeof(sha_hex));
|
|
|
|
/* provider 0 uppercase */
|
|
Curl_strntoupper(provider0, provider0, strlen(provider0));
|
|
|
|
/*
|
|
* Google allows using RSA key instead of HMAC, so this code might change
|
|
* in the future. For now we ony support HMAC.
|
|
*/
|
|
str_to_sign = curl_maprintf("%s4-HMAC-SHA256\n" /* Algorithm */
|
|
"%s\n" /* RequestDateTime */
|
|
"%s\n" /* CredentialScope */
|
|
"%s", /* HashedCanonicalRequest in hex */
|
|
provider0,
|
|
timestamp,
|
|
credential_scope,
|
|
sha_hex);
|
|
if(!str_to_sign) {
|
|
goto fail;
|
|
}
|
|
|
|
/* provider 0 uppercase */
|
|
secret = curl_maprintf("%s4%s", provider0,
|
|
data->state.aptr.passwd ?
|
|
data->state.aptr.passwd : "");
|
|
if(!secret)
|
|
goto fail;
|
|
|
|
HMAC_SHA256(secret, strlen(secret), date, strlen(date), sign0);
|
|
HMAC_SHA256(sign0, sizeof(sign0), region, strlen(region), sign1);
|
|
HMAC_SHA256(sign1, sizeof(sign1), service, strlen(service), sign0);
|
|
HMAC_SHA256(sign0, sizeof(sign0), request_type, strlen(request_type), sign1);
|
|
HMAC_SHA256(sign1, sizeof(sign1), str_to_sign, strlen(str_to_sign), sign0);
|
|
|
|
sha256_to_hex(sha_hex, sign0, sizeof(sha_hex));
|
|
|
|
/* provider 0 uppercase */
|
|
auth_headers = curl_maprintf("Authorization: %s4-HMAC-SHA256 "
|
|
"Credential=%s/%s, "
|
|
"SignedHeaders=%s, "
|
|
"Signature=%s\r\n"
|
|
"%s\r\n",
|
|
provider0,
|
|
user,
|
|
credential_scope,
|
|
Curl_dyn_ptr(&signed_headers),
|
|
sha_hex,
|
|
date_header);
|
|
if(!auth_headers) {
|
|
goto fail;
|
|
}
|
|
|
|
Curl_safefree(data->state.aptr.userpwd);
|
|
data->state.aptr.userpwd = auth_headers;
|
|
data->state.authhost.done = TRUE;
|
|
ret = CURLE_OK;
|
|
|
|
fail:
|
|
Curl_dyn_free(&canonical_headers);
|
|
Curl_dyn_free(&signed_headers);
|
|
free(canonical_request);
|
|
free(request_type);
|
|
free(credential_scope);
|
|
free(str_to_sign);
|
|
free(secret);
|
|
free(date_header);
|
|
return ret;
|
|
}
|
|
|
|
#endif /* !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_CRYPTO_AUTH) */
|