AWS execute API request using QT 5 - c++

Question

i am trying to create an API request to an AWS API, right now i fix the first issue that is related to generate de signature version 4, but no matter what i do, AWS response tell me that the signature is not welll generated, i already check the signature using nodejs code and works, according what i see and what AWS SUpport say, it is possible that some request headers are missing.
I am adding my QT Code i know that is not the best but is only an example, the function that i using to make the post request is loginWekall
#include "hash.h"
#include <QDateTime>
#include <QJsonObject>
#include <QJsonDocument>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QBuffer>
#include <QNetworkReply>
CryptoHash::CryptoHash(QObject *parent) : QObject(parent)
{
}
QString CryptoHash::getKey(){
return this->key;
}
void CryptoHash::setKey(QString key){
this->key = key;
}
void CryptoHash::setSecret(QString secret){
this->secret = secret;
}
void CryptoHash::setRegion(QString region){
this->region = region;
}
void CryptoHash::setMethod(QString method){
this->method = method;
}
void CryptoHash::setEndpoint(QString endpoint){
this->endpoint = endpoint;
}
void CryptoHash::setHost(QString host){
this->host = host;
}
void CryptoHash::setURL(QString URL){
this->url = URL;
}
QString CryptoHash::getHash() {
return this->hashvalue;
}
const QByteArray CryptoHash::getSignatureKey(QString datestamp) {
QMessageAuthenticationCode code(QCryptographicHash::Sha256);
code.setKey(datestamp.toUtf8());
code.addData("AWS4" + this->key.toUtf8());
QByteArray kDate = code.result();
code.reset();
code.setKey(this->region.toUtf8());
code.addData(kDate);
QByteArray kRegion = code.result();
code.reset();
code.setKey(this->service.toUtf8());
code.addData(kRegion);
QByteArray kService = code.result();
code.reset();
code.setKey("aws4_request");
code.addData(kService);
const QByteArray kSignin = code.result();
return kSignin;
}
QByteArray CryptoHash::algorithmDesignation(const QCryptographicHash::Algorithm algorithm) {
switch (algorithm) {
case QCryptographicHash::Md4: return "AWS4-HMAC-MD4";
case QCryptographicHash::Md5: return "AWS4-HMAC-MD5";
case QCryptographicHash::Sha1: return "AWS4-HMAC-SHA1";
case QCryptographicHash::Sha224: return "AWS4-HMAC-SHA224";
case QCryptographicHash::Sha256: return "AWS4-HMAC-SHA256";
case QCryptographicHash::Sha384: return "AWS4-HMAC-SHA384";
case QCryptographicHash::Sha512: return "AWS4-HMAC-SHA512";
default:
Q_ASSERT_X(false, Q_FUNC_INFO, "invalid algorithm");
return "invalid-algorithm";
}
}
QByteArray CryptoHash::canonicalHeader(const QByteArray &headerName, const QByteArray &headerValue) {
QByteArray header = headerName.toLower() + ':';
const QByteArray trimmedHeaderValue = headerValue.trimmed();
bool isInQuotes = false;
char previousChar = '\0';
for (int index = 0; index < trimmedHeaderValue.size(); ++index) {
char thisChar = trimmedHeaderValue.at(index);
header += thisChar;
if (isInQuotes) {
if ((thisChar == '"') && (previousChar != '\\'))
isInQuotes = false;
} else {
if ((thisChar == '"') && (previousChar != '\\')) {
isInQuotes = true;
} else if (isspace(thisChar)) {
while ((index < trimmedHeaderValue.size()-1) &&
(isspace(trimmedHeaderValue.at(index+1))))
++index;
}
}
previousChar = thisChar;
}
return header;
}
QByteArray CryptoHash::canonicalHeaders(const QNetworkRequest &request, QByteArray * const signedHeaders) {
Q_CHECK_PTR(signedHeaders);
signedHeaders->clear();
QMap<QByteArray,QByteArray> headers;
foreach (const QByteArray &rawHeader, request.rawHeaderList()) {
headers.insert(rawHeader.toLower(), request.rawHeader(rawHeader));
}
headers.insert("host", request.url().host().toUtf8());
headers.insert("x-amz-date", this->amz.toUtf8());
QByteArray canonicalHeaders;
for (QMap<QByteArray,QByteArray>::const_iterator iter = headers.constBegin(); iter != headers.constEnd(); ++iter) {
canonicalHeaders += canonicalHeader(iter.key(), iter.value()) + '\n';
if (!signedHeaders->isEmpty()) *signedHeaders += ';';
*signedHeaders += iter.key();
}
return canonicalHeaders;
}
QByteArray CryptoHash::canonicalRequest(const QNetworkAccessManager::Operation operation,
const QNetworkRequest &request,
const QByteArray &payload,
QByteArray * const signedHeaders) {
//qInfo() <<"payload";
//qInfo() << payload;
//qInfo() << QCryptographicHash::hash(payload, QCryptographicHash::Sha256).toHex();
return this->method.toUtf8() + '\n' +
this->endpoint.toUtf8() + '\n' +
"\n" + canonicalHeaders(request, signedHeaders) + '\n' +
*signedHeaders + '\n' +
QCryptographicHash::hash(payload, QCryptographicHash::Sha256).toHex();
}
QByteArray CryptoHash::credentialScope(const QDateTime &date, const QString &region, const QString &service) {
return this->dstamp.toUtf8() + '/' + region.toUtf8() + '/' + service.toUtf8() + "/aws4_request";
}
QByteArray CryptoHash::stringToSign(const QByteArray &algorithmDesignation, const QString &requestDate,
const QByteArray &credentialScope, const QByteArray &canonicalRequest) {
return algorithmDesignation + '\n' +
this->amz.toUtf8() + '\n' +
credentialScope + '\n' +
QCryptographicHash::hash(canonicalRequest, QCryptographicHash::Sha256).toHex();
}
QByteArray CryptoHash::signingKey( const QDate &date,
const QString &region, const QString &service) {
const QCryptographicHash::Algorithm hashAlgorithm = QCryptographicHash::Sha256;
return QMessageAuthenticationCode::hash("aws4_request",
QMessageAuthenticationCode::hash(service.toUtf8(),
QMessageAuthenticationCode::hash(region.toUtf8(),
QMessageAuthenticationCode::hash(this->dstamp.toUtf8(), "AWS4"+this->secret.toUtf8(),
hashAlgorithm), hashAlgorithm), hashAlgorithm), hashAlgorithm);
}
void debugRequest(QNetworkRequest request, QByteArray data = QByteArray())
{
qDebug() << request.url().toString();
const QList<QByteArray>& rawHeaderList(request.rawHeaderList());
foreach (QByteArray rawHeader, rawHeaderList) {
qDebug() << request.rawHeader(rawHeader);
}
qDebug() << data;
}
QString CryptoHash::loginWekall(const QString AWSV4, const QString timestamp){
QNetworkAccessManager *manager = new QNetworkAccessManager(this);
QUrl url("https://asdasdasd.execute-api.us-east-1.amazonaws.com/master/users/login");
QNetworkRequest request(url);
QJsonObject obj;
obj["email"] = "user#test.co";
obj["password"] = "password";
QJsonDocument doc(obj);
QByteArray data = doc.toJson();
// FIXME for debug
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
request.setRawHeader("Content-Type", "application/json");
request.setRawHeader("Authorization", AWSV4.toUtf8());
request.setRawHeader("X-Amz-Date", this->amz.toUtf8());
request.setRawHeader("Host","g298zqijvh.execute-api.us-east-1.amazonaws.com");
request.setRawHeader("Accept","application/json, text/plain, */*");
qDebug() << request.url().toString();
const QList<QByteArray>& rawHeaderList(request.rawHeaderList());
foreach (QByteArray rawHeader, rawHeaderList) {
qDebug() << request.rawHeader(rawHeader);
}
qDebug() << data;
QNetworkReply *reply = manager->post(request, data);
QObject::connect(reply, &QNetworkReply::finished, [=](){
if(reply->error() == QNetworkReply::NoError){
QString contents = QString::fromUtf8(reply->readAll());
qDebug() << contents;
}
else{
qInfo()<< QString::fromUtf8(reply->readAll());
QString err = reply->errorString();
qDebug() << err;
}
reply->deleteLater();
});
return "true";
}
QString CryptoHash::getDate(){
return this->amz;
}
QString CryptoHash::hash(){
const QDateTime datetime;
QDateTime* dtime = new QDateTime();
QString amzdate = dtime->currentDateTimeUtc().toString("yyyyMMddThhmmssZ").toUtf8();
QString datestamp = dtime->currentDateTimeUtc().toString("yyyyMMdd").toUtf8();
QJsonObject data;
this->amz = amzdate;
//this->amz = "20210306T142037Z";
this->dstamp = datestamp;
qInfo() <<"amztime";
qInfo() << amzdate;
qInfo() <<"date";
qInfo() << datestamp;
data["email"] = "user#test.co";
data["password"] = "password";
QJsonDocument doc(data);
QByteArray strData(doc.toJson(QJsonDocument::Compact));
qInfo() << "JSON parameters";
qInfo() << strData;
const QByteArray algorithmDesignation = this->algorithmDesignation(QCryptographicHash::Sha256);
const QString endpoint = this->endpoint;
QString signa = "host;x-amz-date";;
const QByteArray credentialScope = this->credentialScope(datetime, this->region, this->service);
QString access = "ACCESSKEYID/";
this->scope = access.toUtf8() + this->dstamp+ "/us-east-1/execute-api/aws4_request";
qInfo() << "credentialScope";
qInfo() << credentialScope;
QByteArray signedHeaders = signa.toUtf8();
qInfo() << "signedHeaders";
qInfo() << signedHeaders;
const QUrl URL("https://asdasd.execute-api.us-east-1.amazonaws.com/master/users/login");
const QNetworkRequest request(URL);
const QByteArray canonicalRequest = this->canonicalRequest(QNetworkAccessManager::Operation::PostOperation, request, strData, &signedHeaders);
qInfo() << "canonical request";
qInfo() << canonicalRequest;
const QByteArray stringToSign = this->stringToSign(algorithmDesignation, this->amz, credentialScope, canonicalRequest);
qInfo() << "stringToSign";
qInfo() << stringToSign;
const QByteArray signingKey = this->signingKey(datetime.date(), this->region, this->service);
qInfo() << "signinKey";
qInfo() << signingKey;
const QByteArray signature = QMessageAuthenticationCode::hash(stringToSign, signingKey, QCryptographicHash::Sha256);
qInfo() << "signature";
qInfo() << signature;
this->hashvalue = algorithmDesignation + " Credential=" + this->key.toUtf8() + '/' + credentialScope +
", SignedHeaders=" + signedHeaders + ", Signature=" + signature.toHex();
qInfo() << "AWS SIGNATURE VERSION 4";
qInfo() << this->hashvalue;
this->loginWekall(hashvalue, this->amz);
return 0;
}
CryptoHash::~CryptoHash(){};