[PYTHON] Versuchen Sie, Ihr eigenes AWS-SDK mit bash zu erstellen

Überblick

Ich habe AWS-SDK mit Bash gemacht. AWS-AWS kann auch PCs verarbeiten, die kein SDK oder keine Programmierumgebung haben.

Bei der Herstellung versuche ich, die folgenden Bedingungen zu beachten.

• Verwenden Sie Plain Bash (diesmal Git Bash), verwenden Sie nichts, was nicht in Standard Git Bash enthalten ist
• Verwenden Sie keine Programmiersprache. Lösen mit awk, sed, bash
• Verwenden Sie dieselben Profilinformationen wie AWS (~ / .aws / credentials).

Artikel können für jeden Dienst geöffnet und geschlossen werden. Lesen Sie daher bitte nur die Dienste, die Sie benötigen.

Diagramm

Das fertige Produkt

Da es nicht möglich ist, die Funktion aller Funktionen des SDK zu überprüfen, werden wir in diesem Artikel nur die unten stehende Funktion überprüfen.

• DynamoDB-Daten bearbeiten
• Führen Sie Lambda direkt aus
• Bearbeiten Sie die SQS-Daten
• Holen Sie sich eigene Profilinformationen von STS

• Da S3 einen großen Unterschied hat, wird es von diesem Skript nicht unterstützt. Wir haben keine Tests durchgeführt, die über die einfache Funktionsprüfung hinausgehen. Verwenden Sie diese daher auf eigenes Risiko.

Vor Gebrauch: Profil vorbereiten

Wenn Sie es verwenden, erstellen Sie bitte Profilinformationen in ~ / .aws / credentials. Das Format ist Text und es ist keine Erweiterung erforderlich.

~/.aws/credentials

[default]
aws_access_key_id = AKIA**************************
aws_secret_access_key = *****************************

Funktionsprüfung: Manipulieren Sie DynamoDB-Daten

./aws-sdk-bash.sh "default" "ap-northeast-1" "dynamodb" "/" "" \
"content-type:application/x-amz-json-1.0;host:@;x-amz-date:@;x-amz-target:DynamoDB_20120810.GetItem" \
"{\"TableName\": \"target_table\", \"Key\": {\"id\": {\"S\": \"key\"}}}"

{"Item":{"entity":{"S":"string_data"},"id":{"S":"key"}}}

from boto3 import Session
Session(
    profile_name = "default", 
    region_name = "ap-northeast-1"
).client(
    service_name = "dynamodb"
).get_item(
    TableName = "target_table",
    Key = {"id" : {"S" : "key"}}
)

#Daten eingeben
./aws-sdk-bash.sh "default" "ap-northeast-1" "dynamodb" "/" "" \
"content-type:application/x-amz-json-1.0;host:@;x-amz-date:@;x-amz-target:DynamoDB_20120810.PutItem" \
"{\"TableName\": \"target_table\", \"Item\": {\"id\": {\"S\": \"newData\"}, \"entity\":{\"S\":\"new_string_data\"}}}"

{}

#Überprüfen Sie nach Eingabe der Daten, ob die Anzahl der Fälle mit Scan zunimmt
./aws-sdk-bash.sh "default" "ap-northeast-1" "dynamodb" "/" "" \
"content-type:application/x-amz-json-1.0;host:@;x-amz-date:@;x-amz-target:DynamoDB_20120810.Scan" \
"{\"TableName\": \"target_table\"}"

{"Count":2,"Items":[{"entity":{"S":"new_string_data"},"id":{"S":"newData"}},{"entity":{"S":"string_data"},"id":{"S":"key"}}],"ScannedCount":2}

Funktionsprüfung: Lambda direkt ausführen

./aws-sdk-bash.sh "default" "ap-northeast-1" "lambda" "/2015-03-31/functions/sample_lambda/invocations" "" \
"host:@;x-amz-content-sha256:@;x-amz-date:@;x-amz-invocation-type:RequestResponse;x-amz-user-agent:aws-sdk-js/2.668.0 callback" \
"{\"Message\":\"Hello\"}"

{"statusCode": 200, "body": "\"Hello from Lambda! I am SAMPLE\""}

from boto3 import Session
import json
Session(
    profile_name = "default", 
    region_name = "ap-northeast-1"
).client(
    service_name = "lambda"
).invoke(
    FunctionName = "sample_lambda",
    InvocationType = "RequestResponse",
    Payload = json.dumps({"Message" : "Hello"})
)

Funktionsprüfung: Bearbeiten Sie die SQS-Daten

#Nachricht senden
./aws-sdk-bash.sh "default" "ap-northeast-1" "sqs" "/" "" \
"host:@;x-amz-content-sha256:@;x-amz-date:@;x-amz-user-agent:aws-sdk-js/2.668.0 callback" \
"Action=SendMessage&MessageBody=%7B%22id%22%3A%22NewMessage%22%7D&QueueUrl=https%3A%2F%2Fsqs.ap-northeast-1.amazonaws.com%2F***********************%2Fsqs-send-request-test-0424&Version=2012-11-05"

<?xml version="1.0"?><SendMessageResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/"><SendMessageResult><MessageId>013a849d-f344-4d90-a6be-e37302c6b029</MessageId><MD5OfMessageBody>abc832604cb20908715bca6f197c8945</MD5OfMessageBody></SendMessageResult><ResponseMetadata><RequestId>01e07779-a593-5162-b698-2050d59e1524</RequestId></ResponseMetadata></SendMessageResponse>

#Erhalten Sie die Nachricht, die Sie gesendet haben
./aws-sdk-bash.sh "default" "ap-northeast-1" "sqs" "/" "" \
"host:@;x-amz-content-sha256:@;x-amz-date:@;x-amz-user-agent:aws-sdk-js/2.668.0 callback" \
"Action=ReceiveMessage&QueueUrl=https%3A%2F%2Fsqs.ap-northeast-1.amazonaws.com%2F*****************%2Fsqs-send-request-test-0424&Version=2012-11-05"

<?xml version="1.0"?><ReceiveMessageResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/"><ReceiveMessageResult><Message><MessageId>6335c486-d1b6-4478-84c4-40b92f5d655b</MessageId><ReceiptHandle>***********</ReceiptHandle><MD5OfBody>abc832604cb20908715bca6f197c8945</MD5OfBody><Body>{&quot;id&quot;:&quot;NewMessage&quot;}</Body></Message></ReceiveMessageResult><ResponseMetadata><RequestId>9e05f85b-4a27-5d6f-97c4-af723bb68a70</RequestId></ResponseMetadata></ReceiveMessageResponse>

from boto3 import Session
import json
Session(
    profile_name = "default", 
    region_name = "ap-northeast-1"
).client(
    service_name = "sqs"
).send_message(
    QueueUrl = "https://sqs.ap-northeast-1.amazonaws.com/**************/sqs-send-request-test-0424",
    MessageBody = json.dumps({"id": "NewMessage"})
)

Funktionsprüfung: Holen Sie sich eigene Profilinformationen von STS

#Holen Sie sich Ihre eigenen Informationen
./aws-sdk-bash.sh "default" "ap-northeast-1" "sts" "/" "" \
"host:@;x-amz-content-sha256:@;x-amz-date:@;x-amz-user-agent:aws-sdk-js/2.668.0 callback" \
"Action=GetCallerIdentity&Version=2011-06-15"

<GetCallerIdentityResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/">
  <GetCallerIdentityResult>
    <Arn>arn:aws:iam::*****************:user/**************</Arn>
    <UserId>*****************</UserId>
    <Account>*****************</Account>
  </GetCallerIdentityResult>
  <ResponseMetadata>
    <RequestId>1703851c-5b55-49b5-8bcf-130ab4dbb6f2</RequestId>
  </ResponseMetadata>
</GetCallerIdentityResponse>

from boto3 import Session
Session(
    profile_name = "default", 
    region_name = "ap-northeast-1"
).client(
    service_name = "sts"
).get_caller_identity()

Quellcode

Wenn Sie es ausführen möchten, speichern Sie es an einem beliebigen Ort mit dem Dateinamen aws-sdk-bash.sh. Informationen zum auszuführenden Befehl finden Sie unter "Funktionsprüfung".

aws-sdk-bash.sh

#!/bin/bash

#Der Profilpfad ist festgelegt
CREDENTIALS_FILE=~/.aws/credentials
#Algorithmus ist Signatur v4, SHA256 von hmac
ALGORITHM='AWS4-HMAC-SHA256'

#Skriptargumente
_INPUT_PROFILE_NAME=$1
_INPUT_REGION=$2
_INPUT_SERVICE=$3
_INPUT_CANONICAL_URI=$4
_INPUT_CANONICAL_QUERY_STRING=$5
_INPUT_OPTIONAL_HEADERS=$6
_INPUT_PAYLOAD=$7

#Erstellen eines Endpunkts
METHOD=POST
PROTOCOL=https
HOST_NAME=${_INPUT_SERVICE}.${_INPUT_REGION}.amazonaws.com

# .Holen Sie sich Profilinformationen aus der aws-Datei
#Geben Sie den Profilpfad, den Profilnamen, den Profilschlüsselnamen und die Anzahl der zu lesenden Zeilen ein
get_credentials () {
    _CREDENTIALS_FILE=$1; _PROFILE_NAME=$2; _KEY_NAME=$3; _READ_LENGTH=$4;

    # PROFILE_Holen Sie sich die Zeilennummer von NAME
    PROFILE_IDX=`nl $_CREDENTIALS_FILE | grep $_PROFILE_NAME | head -n 1 | awk '{print $1}'`
    PROFILE_IDX_END=`expr $PROFILE_IDX + $_READ_LENGTH`

    #Zugriffsschlüssel-ID abrufen
    RESULT=`cat $CREDENTIALS_FILE | sed -n "${PROFILE_IDX},${PROFILE_IDX_END}p" | grep "=" | grep ${_KEY_NAME} | \
    tr -d " " | sed "s/=/ /g" | awk '{print $2}' | \
    head -n 1`

    echo -n $RESULT
}

#Erstellen Sie einen Hash mit SHA256
#Eingabenachricht: Datei, Schlüssel: keine
#Ausgabe-Hash: Hex-Format
create_digest_from_file () {
    cat $1 | openssl dgst -sha256 | grep stdin | awk '{print $2}'
}

# HMAC-Erstellen Sie einen Hash mit SHA256
#Eingabenachricht: Text, Schlüssel: Text
#Ausgabe-Hash: Hex-Format
sign_from_string () {
    echo -n $2 | openssl dgst -sha256 -hmac $1 | grep stdin | awk '{print $2}'
}

# HMAC-Erstellen Sie einen Hash mit SHA256
#Eingabenachricht: Text, Schlüssel: Hex-Format
#Ausgabe-Hash: Hex-Format
sign_from_string_with_hex_key () {
    echo -n $2 | openssl dgst -sha256 -mac hmac -macopt hexkey:$1 | grep stdin | awk '{print $2}'
}

# HMAC-Erstellen Sie einen Hash mit SHA256
#Eingabenachricht: Datei, Schlüssel: Hex-Format
#Ausgabe-Hash: Hex-Format
sign_from_file_with_hex_key () {
    cat $2 | openssl dgst -sha256 -mac hmac -macopt hexkey:$1 | grep stdin | awk '{print $2}'
}

#HMAC-Basisinformationen der Signatur v4 (Zugriffsschlüssel-ID, Datum und Uhrzeit der Übertragung, Region, Dienstname)-Hash mit SHA256
get_signature_key () {
    TEMP_DATE=`sign_from_string AWS4$1 $2`
    TEMP_REGION=`sign_from_string_with_hex_key $TEMP_DATE $3`
    TEMP_SERVICE=`sign_from_string_with_hex_key $TEMP_REGION $4`
    sign_from_string_with_hex_key $TEMP_SERVICE 'aws4_request'
}

#Zugriffsschlüssel-ID abrufen
ACCESS_KEY_ID=`get_credentials $CREDENTIALS_FILE ${_INPUT_PROFILE_NAME} aws_access_key_id 2`

#Holen Sie sich einen geheimen Zugangsschlüssel
SECRET_ACCESS_KEY=`get_credentials $CREDENTIALS_FILE ${_INPUT_PROFILE_NAME} aws_secret_access_key 2`

#Datum und Uhrzeit der UTC abrufen (Formatbeispiel: 2020/12/31T12:34:Bei 50 AMZ_DATE:20201231T123450Z DATE_STAMP:20201231）
UTC_DATE=`date -Iseconds -u | sed "s/+/ /g" | awk '{print $1 "Z"}'`
AMZ_DATE=`echo -n $UTC_DATE | sed "s/-//g" | sed "s/://g"`
DATE_STAMP=`echo -n $UTC_DATE | sed "s/-//g" | sed "s/T/ /g" | awk '{print $1}'`

#Temporäre Datei erstellen, temporäre Datei am Ende löschen
TEMP_HEADERS=`mktemp`
TEMP_CANONICAL_REQUEST=`mktemp`
TEMP_STRING_TO_SIGN=`mktemp`
TEMP_PAYLOAD=`mktemp`
trap "rm -f $TEMP_HEADERS; rm -f $TEMP_CANONICAL_REQUEST; rm -f $TEMP_STRING_TO_SIGN; rm -f $TEMP_PAYLOAD" EXIT

#Kopieren Sie die Nutzdaten in eine temporäre Datei
echo -n ${_INPUT_PAYLOAD} > $TEMP_PAYLOAD

#Erstellen Sie einen SHA256-Hash (ohne Schlüssel) aus den zu sendenden BODY-Daten
PAYLOAD_HASH=`create_digest_from_file $TEMP_PAYLOAD`

#Setzen Sie den Sendeheader
echo -n "${_INPUT_OPTIONAL_HEADERS}" | sed "s#x-amz-content-sha256:@#x-amz-content-sha256:${PAYLOAD_HASH}#" | sed "s#host:@#host:${HOST_NAME}#" | sed "s#x-amz-date:@#x-amz-date:${AMZ_DATE}#" | xargs -d ";" -r -I @ echo @ >> $TEMP_HEADERS
SIGNED_HEADERS=`echo -n "${_INPUT_OPTIONAL_HEADERS}" | xargs -d ";" -r -I @ echo ";@" | sed 's/:.*//'`
SIGNED_HEADERS=`echo -n $SIGNED_HEADERS | sed 's/ //g' | sed 's/^;//'`

#Machen Sie eine kanonische Anfrage
#Anforderungsinformationen standardisieren
#Referenzinformationen: Aufgabe 1:Stellen Sie eine legitime Anfrage für die signierte Version 4
# https://docs.aws.amazon.com/ja_jp/general/latest/gr/sigv4-create-canonical-request.html
echo $METHOD > $TEMP_CANONICAL_REQUEST
echo $_INPUT_CANONICAL_URI >> $TEMP_CANONICAL_REQUEST
echo $_INPUT_CANONICAL_QUERY_STRING >> $TEMP_CANONICAL_REQUEST
cat $TEMP_HEADERS >> $TEMP_CANONICAL_REQUEST
echo "" >> $TEMP_CANONICAL_REQUEST
echo $SIGNED_HEADERS >> $TEMP_CANONICAL_REQUEST
echo -n $PAYLOAD_HASH >> $TEMP_CANONICAL_REQUEST

#Erstellen Sie eine Signaturzeichenfolge
#Referenzinformationen: Aufgabe 2:Erstellen Sie eine Signaturzeichenfolge der Version 4
# https://docs.aws.amazon.com/ja_jp/general/latest/gr/sigv4-create-string-to-sign.html
CANONICAL_REQUEST_HASH=`create_digest_from_file $TEMP_CANONICAL_REQUEST`
CREDENTIAL_SCOPE=${DATE_STAMP}/${_INPUT_REGION}/${_INPUT_SERVICE}/"aws4_request"

#Legen Sie den Signaturalgorithmus und den Signaturbereich fest
echo ${ALGORITHM} > $TEMP_STRING_TO_SIGN
echo ${AMZ_DATE} >> $TEMP_STRING_TO_SIGN
echo ${CREDENTIAL_SCOPE} >> $TEMP_STRING_TO_SIGN
echo -n ${CANONICAL_REQUEST_HASH} >> $TEMP_STRING_TO_SIGN

#Unterschrift für Unterschrift berechnen
#Referenzinformationen: Aufgabe 3:AWS-Zeichen Berechnen Sie die Signatur der Version 4
# https://docs.aws.amazon.com/ja_jp/general/latest/gr/sigv4-calculate-signature.html
SIGNING_KEY=`get_signature_key ${SECRET_ACCESS_KEY} ${DATE_STAMP} ${_INPUT_REGION} ${_INPUT_SERVICE}`
SIGNATURE=`sign_from_file_with_hex_key ${SIGNING_KEY} ${TEMP_STRING_TO_SIGN}`

#Legen Sie die Signatur im HTTP-Anforderungsheader fest
#Referenzinformationen: Aufgabe 4:Fügen Sie der HTTP-Anforderung eine Signatur hinzu
# https://docs.aws.amazon.com/ja_jp/general/latest/gr/sigv4-add-signature-to-request.html
AUTHORIZATION_HEADER="${ALGORITHM} Credential=${ACCESS_KEY_ID}/${CREDENTIAL_SCOPE}, SignedHeaders=${SIGNED_HEADERS}, Signature=${SIGNATURE}"

#Senden Sie eine HTTP-Anfrage.
QUERY_STRING=${_INPUT_CANONICAL_QUERY_STRING}
if [ ! $QUERY_STRING = "" ]; then
    QUERY_STRING="?${QUERY_STRING}"
fi
curl -s -X POST ${PROTOCOL}://${HOST_NAME}${_INPUT_CANONICAL_URI}${QUERY_STRING} -d @$TEMP_PAYLOAD -H @$TEMP_HEADERS -H "Authorization: ${AUTHORIZATION_HEADER}"

Erklärung des Quellcodes

Der Verarbeitungsablauf ist wie folgt. Es gibt verschiedene SDKs für verschiedene Sprachen. Wenn Sie diese vier jedoch implementieren, können Sie dasselbe wie beim AWS-SDK tun.

\def\von{\unicode[serif]{x306E}}
\bbox[8px, border: 2px solid gray]{\rlap{\tt 1.\Quad-Profilinformationen\Erhalten}\hspace{80mm}}

\triangledown

\def\von{\unicode[serif]{x306E}}
\bbox[8px, border: 2px solid gray]{\rlap{\tt 2.\Quad-Parameter\Holen und erstellen}\hspace{80mm}}

\triangledown

\bbox[8px, border: 2px solid gray]{\rlap{\tt 3.\Hash Quad Parameter mit SHA256}\hspace{80mm}}

\triangledown

\bbox[8px, border: 2px solid gray]{\rlap{\tt 4.\HTTP-Anfrage mit Quad Curl senden}\hspace{80mm}}

Informationen zum Signieren von Version 4 finden Sie im offiziellen AWS "Beispiel für einen vollständig signierten Signierprozess von Version 4 (Python)" -request-examples.html) Bitte beziehen Sie sich auf.

Im Folgenden wird jeder Prozess erläutert.

1. Erfassung von Profilinformationen

Dies ist der Prozess, um Profilinformationen von ~ / .aws / credentials abzurufen.

\def\von{\unicode[serif]{x306E}}
\begin{array}{l|l}
\hline 
Befehl&Zweck\\
\hline 
{\tt nl} &Zeilennummer+Datei\Zeigt den Inhalt von an.\\
&Zeilennummer\Es ist eine Katze, die herauskommt.\\
\hdashline 
{\tt sed\;\text{-n}} &Angegebene Linie\Holen Sie sich den Text von.\\
\hline 
\end{array}

Verwenden Sie "nl + grep profile name", um die Anzahl der Zeilen des abzurufenden Profilnamens abzurufen. "Sed -n" übernimmt die Zeile nach dem Profilnamen. Nehmen Sie daher die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel von dort.

aws-sdk-bash.sh_Signaturinformationen abrufen

# .Holen Sie sich Profilinformationen aus der aws-Datei
#Geben Sie den Profilpfad, den Profilnamen, den Profilschlüsselnamen und die Anzahl der zu lesenden Zeilen ein
get_credentials () {
    _CREDENTIALS_FILE=$1; _PROFILE_NAME=$2; _KEY_NAME=$3; _READ_LENGTH=$4;

    # PROFILE_Holen Sie sich die Zeilennummer von NAME
    PROFILE_IDX=`nl $_CREDENTIALS_FILE | grep $_PROFILE_NAME | head -n 1 | awk '{print $1}'`
    PROFILE_IDX_END=`expr $PROFILE_IDX + $_READ_LENGTH`

    #Zugriffsschlüssel-ID abrufen
    RESULT=`cat $CREDENTIALS_FILE | sed -n "${PROFILE_IDX},${PROFILE_IDX_END}p" | grep "=" | grep ${_KEY_NAME} | \
    tr -d " " | sed "s/=/ /g" | awk '{print $2}' | \
    head -n 1`

    echo -n $RESULT
}

aws-sdk-bash.sh_Anrufer

#Zugriffsschlüssel-ID abrufen
ACCESS_KEY_ID=`get_credentials $CREDENTIALS_FILE ${_INPUT_PROFILE_NAME} aws_access_key_id 2`

#Holen Sie sich einen geheimen Zugangsschlüssel
SECRET_ACCESS_KEY=`get_credentials $CREDENTIALS_FILE ${_INPUT_PROFILE_NAME} aws_secret_access_key 2`

2. Parameter abrufen und erstellen

** Datum und Uhrzeit abrufen **

Holen Sie sich Datum und Uhrzeit in UTC. Erstellen Sie eine Zeichenfolge in einem Format, das Stunden, Minuten und Sekunden enthält, und in einem Format, das keine Stunden, Minuten und Sekunden enthält.

\def\von{\unicode[serif]{x306E}}
\begin{array}{l|l}
\hline 
Wert&Format\\
\hline 
{\tt \text{AMZ_DATE}} & {\tt YYYYMMDDTHHMMSS}\Geben Sie das Format an.\\
&Hinter{\tt UTC}Zeigen auf{\tt Z}Ich werde anziehen.\\
&Doppelpunkt, Bindestrich\Fügen Sie keine Symbole wie.\\
\hdashline 
{\tt \text{DATE_STAMP}} & {\tt YYYYMMDD}\Geben Sie das Format an.\\
&Geben Sie nur das Datum an.\\
&Doppelpunkt, Bindestrich\Fügen Sie keine Symbole wie.\\
\hline 
\end{array}

aws-sdk-bash.sh_Holen Sie sich UTC Datum und Uhrzeit

#Datum und Uhrzeit der UTC abrufen (Formatbeispiel: 2020/12/31T12:34:Bei 50 AMZ_DATE:20201231T123450Z DATE_STAMP:20201231）
UTC_DATE=`date -Iseconds -u | sed "s/+/ /g" | awk '{print $1 "Z"}'`
AMZ_DATE=`echo -n $UTC_DATE | sed "s/-//g" | sed "s/://g"`
DATE_STAMP=`echo -n $UTC_DATE | sed "s/-//g" | sed "s/T/ /g" | awk '{print $1}'`

** Text behandeln **

Die Zeichenfolge wird in eine temporäre Datei geschrieben und verarbeitet. Temporäre Dateien werden gelöscht, wenn der Prozess endet.

Sie können mit Bash-Variablen umgehen, aber es ist einfacher zu implementieren, wenn Sie Zeichenfolgen in Dateien verarbeiten. Für Signaturinformationen werden Leerzeilen, Zeilenumbrüche am Ende und die Reihenfolge des Auftretens von Daten streng festgelegt, und wenn sich auch nur eine verschiebt, wird die Signatur nicht bestanden.

\def\von{\unicode[serif]{x306E}}
\begin{array}{l|l}
\hline 
Befehl&Zweck\\
\hline 
{\tt mktemp} & /Erstellen Sie eine temporäre Datei in tmp.\\
&Dateinamen werden ohne Vervielfältigung angegeben\\
&Zugriffsrechte werden ebenfalls entsprechend festgelegt.\\
\hdashline 
{\tt trap} &Spezifisch\Der Befehl wird zum Zeitpunkt von ausgeführt.\\
&Löschen Sie die temporäre Datei am Ende des Vorgangs.\\
\hline 
\end{array}

aws-sdk-bash.sh_Temporäre Datei erstellen

#Temporäre Datei erstellen, temporäre Datei am Ende löschen
TEMP_HEADERS=`mktemp`
TEMP_CANONICAL_REQUEST=`mktemp`
TEMP_STRING_TO_SIGN=`mktemp`
TEMP_PAYLOAD=`mktemp`
trap "rm -f $TEMP_HEADERS; rm -f $TEMP_CANONICAL_REQUEST; rm -f $TEMP_STRING_TO_SIGN; rm -f $TEMP_PAYLOAD" EXIT

** Parameter ersetzen **

Es gibt einige Parameter, die dem Benutzer bei der Anforderung nicht bekannt sind. Solche Parameter werden auf der Skriptseite festgelegt, indem der Wert mit @ weggelassen wird.

\begin{array}{ll}
Benutzerdefinierte Parameter& {\tt \text{x-amz-date:@}} \\
Tatsächlich gesendete Parameter& {\tt \text{x-amz-date:20200504T145432Z}}\\
& \\
\end{array}

\def\von{\unicode[serif]{x306E}}
\begin{array}{l|l}
\hline 
Header\Schlüssel von&Wert eingestellt werden\\
\hline 
{\tt \text{x-amz-content-sha256}} &Nutzlast\Hash-Wert von\\
\hdashline 
{\tt host} & {\tt AWS-Endpunkt\URL}\\
\hdashline 
{\tt \text{x-amz-date}}  &Datum und Uhrzeit der Anfrage\\
\hline 
\end{array}

aws-sdk-bash.sh_Kopfzeile setzen

#Erstellen Sie einen SHA256-Hash (ohne Schlüssel) aus den zu sendenden BODY-Daten
PAYLOAD_HASH=`create_digest_from_file $TEMP_PAYLOAD`

#Setzen Sie den Sendeheader
echo -n "${_INPUT_OPTIONAL_HEADERS}" | sed "s#x-amz-content-sha256:@#x-amz-content-sha256:${PAYLOAD_HASH}#" | sed "s#host:@#host:${HOST_NAME}#" | sed "s#x-amz-date:@#x-amz-date:${AMZ_DATE}#" | xargs -d ";" -r -I @ echo @ >> $TEMP_HEADERS
SIGNED_HEADERS=`echo -n "${_INPUT_OPTIONAL_HEADERS}" | xargs -d ";" -r -I @ echo ";@" | sed 's/:.*//'`
SIGNED_HEADERS=`echo -n $SIGNED_HEADERS | sed 's/ //g' | sed 's/^;//'`

3. Hashing

Um HMAC-SHA256 zu erhalten, schreiben Sie wie folgt in Python.

HMAC-Holen Sie sich SHA256

def sign(key, msg):
    return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()

def getSignatureKey(key, dateStamp, regionName, serviceName):
    kDate = sign(("AWS4" + key).encode("utf-8"), dateStamp)
    kRegion = sign(kDate, regionName)
    kService = sign(kRegion, serviceName)
    kSigning = sign(kService, "aws4_request")
    return kSigning

Verwenden Sie openssl, um dasselbe mit bash zu tun.

\def\von{\unicode[serif]{x306E}}
\begin{array}{l|l}
\hline 
Befehl&Zweck\\
\hline 
{\tt openssl\;dgst\;\text{-}sha256} &Text{\tt SHA256}Hash mit.\\
&Das Ergebnis ist eine Hexadezimalzahl.\\
\hdashline 
{\tt openssl\;dgst\;\text{-}sha256} &Text{\tt SHA256}Hash mit.\\
\qquad{\tt \text{-}hmac\;(key)} &Klartext\Geben Sie den Schlüssel von an.\\
&Das Ergebnis ist eine Hexadezimalzahl.\\
\hdashline 
{\tt openssl\;dgst\;\text{-}sha256} &Text{\tt SHA256}Hash mit.\\
\qquad{\tt \text{-}mac\;hmac} &Hexadezimal\Geben Sie den Schlüssel von an.\\
\qquad{\tt \text{-}macopt\;hexkey:(key)}&Das Ergebnis ist eine Hexadezimalzahl.\\
\hline 
\end{array}

aws-sdk-bash.sh_Hashing

#Erstellen Sie einen Hash mit SHA256
#Eingabenachricht: Datei, Schlüssel: keine
#Ausgabe-Hash: Hex-Format
create_digest_from_file () {
    cat $1 | openssl dgst -sha256 | grep stdin | awk '{print $2}'
}

# HMAC-Erstellen Sie einen Hash mit SHA256
#Eingabenachricht: Text, Schlüssel: Text
#Ausgabe-Hash: Hex-Format
sign_from_string () {
    echo -n $2 | openssl dgst -sha256 -hmac $1 | grep stdin | awk '{print $2}'
}

# HMAC-Erstellen Sie einen Hash mit SHA256
#Eingabenachricht: Text, Schlüssel: Hex-Format
#Ausgabe-Hash: Hex-Format
sign_from_string_with_hex_key () {
    echo -n $2 | openssl dgst -sha256 -mac hmac -macopt hexkey:$1 | grep stdin | awk '{print $2}'
}

# HMAC-Erstellen Sie einen Hash mit SHA256
#Eingabenachricht: Datei, Schlüssel: Hex-Format
#Ausgabe-Hash: Hex-Format
sign_from_file_with_hex_key () {
    cat $2 | openssl dgst -sha256 -mac hmac -macopt hexkey:$1 | grep stdin | awk '{print $2}'
}

#HMAC-Basisinformationen der Signatur v4 (Zugriffsschlüssel-ID, Datum und Uhrzeit der Übertragung, Region, Dienstname)-Hash mit SHA256
#Gleicher Prozess wie getSignatureKey in Python
get_signature_key () {
    TEMP_DATE=`sign_from_string AWS4$1 $2`
    TEMP_REGION=`sign_from_string_with_hex_key $TEMP_DATE $3`
    TEMP_SERVICE=`sign_from_string_with_hex_key $TEMP_REGION $4`
    sign_from_string_with_hex_key $TEMP_SERVICE 'aws4_request'
}

So überprüfen Sie die AWS-SDK-Anforderung

Die vom AWS-SDK ausgelösten Formate von Nutzdaten und Headern variieren von Dienst zu Dienst. Es gibt keine offizielle Dokumentation, daher müssen Sie diese selbst nachschlagen.

So überprüfen Sie mit boto3 + Wireshark

Wenn Sie so kommunizieren, wie es ist, wird es verschlüsselt, also werde ich ein wenig Arbeit hinzufügen.

Deaktivieren Sie die Verschlüsselung und wechseln Sie zur HTTP-Kommunikation

import boto3
client = boto3.client("dynamodb", use_ssl = False)

print(client.get_item(TableName = "target_table", Key = {"id" : {"S":"key"}}))

Wenn use_ssl auf False gesetzt ist, wird es an Port 80 gesendet. Da es im Klartext kommuniziert, kann es von Wireshark gelesen werden.

Wenn Sie sich Wireshark ansehen, sehen Sie, dass die von uns gesendeten Daten wie folgt lauten.

Text

POST / HTTP/1.1
Host: dynamodb.ap-northeast-1.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: DynamoDB_20120810.GetItem
Content-Type: application/x-amz-json-1.0
User-Agent: Boto3/1.12.43 Python/3.8.2 Windows/10 Botocore/1.15.43
X-Amz-Date: 20200501T213154Z
Authorization: AWS4-HMAC-SHA256 Credential=AKIA**********/20200501/ap-northeast-1/dynamodb/aws4_request, SignedHeaders=content-type;host;x-amz-date;x-amz-target, Signature=***********************************************************
Content-Length: 58

{"TableName": "target_table", "Key": {"id": {"S": "key"}}}

Es ist in Ordnung, wenn Sie die Daten so einstellen, dass dieselbe Anforderung gesendet wird.

Beachten Sie, dass use_ssl mit einigen Diensten nicht verwendet werden kann. Zum Beispiel Lambda und MQTT. Wenn Sie versuchen, mit einem Dienst, der nur HTTPS unterstützt, eine Verbindung zu Port 80 herzustellen, tritt eine Zeitüberschreitung ohne Antwort auf.

• Um zu überprüfen, ob eine Kommunikation ohne SSL möglich ist, fragen Sie AWS "Service-Endpunkt und Kontingenttabelle )"es gibt. Die Kommunikation ist möglich, wenn das Endpunktprotokoll HTTP oder HTTPS ist.

So überprüfen Sie mit der Überprüfungsfunktion des Browsers

Wenn Sie die Nutzdaten in einem Dienst anzeigen möchten, für den SSL erforderlich ist, verwenden Sie die Javascript-Version des SDK.

test.html

<script src="https://sdk.amazonaws.com/js/aws-sdk-2.668.0.min.js"></script>
<script type="text/javascript">
    AWS.config.update({
        accessKeyId : 'AKIA******************',
        secretAccessKey : '**********************************'
    });
    AWS.config.region = 'ap-northeast-1';
    
    let lambda = new AWS.Lambda();
    let params = {
        FunctionName : 'sample_lambda',
        InvocationType : 'RequestResponse',
        Payload : JSON.stringify({
            "Message" : "Hello"
        })
    };
    
    lambda.invoke(params, (err, data) => console.log(JSON.parse(data.Payload)));
</script>

Nachdem Sie den Prozess geschrieben haben, den Sie in die HTML-Datei einchecken möchten, öffnen Sie ihn im Browser. Mit Chrome können Sie Netzwerkkommunikationsdaten überprüfen, indem Sie mit der rechten Maustaste klicken und "Überprüfen" im Browser öffnen.

Es gibt Unterschiede wie browserspezifische Daten und CORS kann erforderlich sein, aber wir haben alle erforderlichen Daten. In diesem Zusammenhang ist es in Ordnung, wenn Sie dieselbe Fluganforderung festlegen.