V4-Signaturprozess mit Ihrem eigenen Programm

Auf dieser Seite wird ein Algorithmus zum Implementieren des V4-Signaturprozesses erläutert, mit dem Sie in Ihrem eigenen Workflow mit Cloud Storage-RSA-Schlüsseln signierte URLs erstellen können. Sie nutzen dazu eine von Ihnen gewählte Programmiersprache.

Hinweise

Bevor Sie ein Programm erstellen, das den V4-Signaturprozess implementiert, führen Sie die folgenden Schritte aus:

Dienstkonto erstellen Wenn Sie bereits ein Dienstkonto haben, können Sie diesen Schritt überspringen.
Erteilen Sie dem Dienstkonto ausreichende Berechtigungen, um die Anfrage der signierten URL ausführen zu können.

Wenn die signierte URL beispielsweise einem Nutzer das Lesen von Objektdaten ermöglicht, muss das Dienstkonto selbst die Berechtigung zum Lesen der Objektdaten haben.
Wenn der zu verwendende Signaturalgorithmus nicht in Google Cloud eingebunden ist, erstellen Sie einen neuen privaten Schlüssel oder haben Sie einen vorhandenen privaten Schlüssel für das Dienstkonto. Der Schlüssel kann entweder im JSON- oder im PKCS12-Format vorliegen.

Algorithmus zum Signieren von URLs

Das Programm sollte folgende Schritte umfassen:

Erstellen der kanonischen Anfrage als String. Die kanonische Anfrage definiert Elemente, die Nutzer in ihre Anfrage aufnehmen müssen, wenn sie Ihre signierte URL verwenden.

Unter kanonische Anfragen finden Sie weitere Informationen zu den erforderlichen Komponenten und Formaten.
Erstellen des zu signierenden Strings. Der zu signierende String ist die Basis für die Erstellung einer Signatur und enthält den hex-codierten Hash-Wert der kanonischen Anfrage.

Weitere Informationen zum Format des zu signierenden Strings finden Sie unter Signaturen.
Signieren Sie den zu signierenden String mit einer RSA-Signatur mit SHA-256. Das Ergebnis dieser Signatur ist Ihre Anfragesignatur. Es gibt mehrere Möglichkeiten zum Signieren:
- Sie können die von Google Cloud bereitgestellte IAM-Methode signBlob verwenden.
- Für Programmiersprachen verwenden Sie eine Programmiersprache mit einer Bibliothek.
Hinweis: Sie können den zu signierenden String auch mit HMAC signieren, wenn Sie die XML API für den interoperablen Zugriff verwenden.

Erstellen der signierten URL mithilfe der folgenden Verkettung:

HOSTNAME + PATH_TO_RESOURCE + "?" + CANONICAL_QUERY_STRING + "&X-Goog-Signature=" + REQUEST_SIGNATURE

Die signierte URL besteht aus folgenden Komponenten:

HOSTNAME: Muss https://storage.googleapis.com sein.
PATH_TO_RESOURCE: Muss mit dem Wert übereinstimmen, den Sie beim Erstellen der kanonischen Anfrage verwendet haben.
CANONICAL_QUERY_STRING: Muss mit den Werten übereinstimmen, die Sie beim Erstellen der kanonischen Anfrage verwendet haben.
REQUEST_SIGNATURE: Die aus der Verwendung einer RSA-Signatur im vorherigen Schritt resultierende Ausgabe.

Die vollständige URL aus diesem Beispiel sieht so aus:

https://storage.googleapis.com/example-bucket/cat.jpeg?X-Goog-Algorithm=GOOG4-
RSA-SHA256&X-Goog-Credential=example%40example-project.iam.gserviceaccount.com
%2F20181026%2Fus%2Fstorage%2Fgoog4_request&X-Goog-Date=20181026T211942Z&X-Goog
-expires=3600&X-Goog-Signedheaders=host&X-Goog-Signature=2d2a6f5055eb004b8690b
9479883292ae7450cdc15f17d7f99bc49b916f9e7429106ed7e5858ae6b4ab0bbbdb1a8ccc364d
ad3a0da2caebd30887a70c5b2569d089ceb8afbde3eed4dff5086f0db5483998c175980991fe89
9fbd2cd8cb813b00165e8d56e0a8aa7b3d7a12ee1baa8400611040f05b50a1a8eab5ba223fe137
5747748de950ec7a4dc50f8382a6ffd4994ac42498d7daa703d9a414d4475154d0e7edaa92d4f2
507d92c1f7e8efa7cab64df68b5df48575b9259d8d0bdb5dc752bdf07bd162d98ff2924f2e4a26
fa6b3cede73ad5333c47d146a21c2ab2d97115986a12c68ff37346d6c2ca83e56b8ec8ad956327
10b489b75c35697d781c38e

Python-Beispielprogramm

Sie können die Cloud Storage-Clientbibliotheken verwenden, um signierte URLs für viele gängige Programmiersprachen zu erstellen. Beispiele finden Sie unter V4-Signaturprozess mit Cloud Storage-Tools.

Das folgende Beispiel zeigt eine Implementierung des Algorithmus zum Signieren von URLs, in dem die Cloud Storage-Clientbibliotheken nicht verwendet wird. Das Beispiel verwendet die Programmiersprache Python, kann jedoch an die Sprache Ihrer Wahl angepasst werden.

import binascii
import collections
import datetime
import hashlib
import sys
from urllib.parse import quote

# pip install google-auth
from google.oauth2 import service_account

# pip install six
import six


def generate_signed_url(
    service_account_file,
    bucket_name,
    object_name,
    subresource=None,
    expiration=604800,
    http_method="GET",
    query_parameters=None,
    headers=None,
):
    if expiration > 604800:
        print("Expiration Time can't be longer than 604800 seconds (7 days).")
        sys.exit(1)

    escaped_object_name = quote(six.ensure_binary(object_name), safe=b"/~")
    canonical_uri = f"/{escaped_object_name}"

    datetime_now = datetime.datetime.now(tz=datetime.timezone.utc)
    request_timestamp = datetime_now.strftime("%Y%m%dT%H%M%SZ")
    datestamp = datetime_now.strftime("%Y%m%d")

    google_credentials = service_account.Credentials.from_service_account_file(
        service_account_file
    )
    client_email = google_credentials.service_account_email
    credential_scope = f"{datestamp}/auto/storage/goog4_request"
    credential = f"{client_email}/{credential_scope}"

    if headers is None:
        headers = dict()
    host = f"{bucket_name}.storage.googleapis.com"
    headers["host"] = host

    canonical_headers = ""
    ordered_headers = collections.OrderedDict(sorted(headers.items()))
    for k, v in ordered_headers.items():
        lower_k = str(k).lower()
        strip_v = str(v).lower()
        canonical_headers += f"{lower_k}:{strip_v}\n"

    signed_headers = ""
    for k, _ in ordered_headers.items():
        lower_k = str(k).lower()
        signed_headers += f"{lower_k};"
    signed_headers = signed_headers[:-1]  # remove trailing ';'

    if query_parameters is None:
        query_parameters = dict()
    query_parameters["X-Goog-Algorithm"] = "GOOG4-RSA-SHA256"
    query_parameters["X-Goog-Credential"] = credential
    query_parameters["X-Goog-Date"] = request_timestamp
    query_parameters["X-Goog-Expires"] = expiration
    query_parameters["X-Goog-SignedHeaders"] = signed_headers
    if subresource:
        query_parameters[subresource] = ""

    canonical_query_string = ""
    ordered_query_parameters = collections.OrderedDict(sorted(query_parameters.items()))
    for k, v in ordered_query_parameters.items():
        encoded_k = quote(str(k), safe="")
        encoded_v = quote(str(v), safe="")
        canonical_query_string += f"{encoded_k}={encoded_v}&"
    canonical_query_string = canonical_query_string[:-1]  # remove trailing '&'

    canonical_request = "\n".join(
        [
            http_method,
            canonical_uri,
            canonical_query_string,
            canonical_headers,
            signed_headers,
            "UNSIGNED-PAYLOAD",
        ]
    )

    canonical_request_hash = hashlib.sha256(canonical_request.encode()).hexdigest()

    string_to_sign = "\n".join(
        [
            "GOOG4-RSA-SHA256",
            request_timestamp,
            credential_scope,
            canonical_request_hash,
        ]
    )

    # signer.sign() signs using RSA-SHA256 with PKCS1v15 padding
    signature = binascii.hexlify(
        google_credentials.signer.sign(string_to_sign)
    ).decode()

    scheme_and_host = "{}://{}".format("https", host)
    signed_url = "{}{}?{}&x-goog-signature={}".format(
        scheme_and_host, canonical_uri, canonical_query_string, signature
    )

    return signed_url

Nächste Schritte

Signieren von URLs mit Cloud Storage-Tools wie Clientbibliotheken oder der Google Cloud CLI
Weitere Informationen zu signierten URLs
Kanonische Anfragen