Processo de assinatura V4 com seu próprio programa

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Nesta página, você verá um algoritmo para implementar o processo de assinatura da V4, para que você possa criar URLs assinados com chave RSA do Cloud Storage no fluxo de trabalho usando uma linguagem de programação de sua escolha.

Antes de começar

Antes de criar um programa que implemente o processo de assinatura da V4, você precisa:

  1. Gerar uma nova chave privada ou ter uma chave privada atual para uma conta de serviço. A chave pode estar no formato JSON ou PKCS12.

    Para mais informações sobre chaves privadas e contas de serviço, consulte Contas de serviço.

  2. Conceda à conta de serviço permissão suficiente para que ela possa executar a solicitação que o URL assinado fará.

    Por exemplo, se o URL assinado permitir que um usuário faça o download de um objeto, a conta de serviço precisará ter a permissão storage.objects.get no objeto.

Algoritmo para assinatura de URLs

Seu programa precisa incluir os seguintes passos:

  1. Construa o pedido canônico como uma string. A solicitação canônica define elementos que os usuários precisam incluir na solicitação quando usam seu URL assinado.

    Consulte Solicitações canônicas para detalhes sobre as partes e o formato necessários.

  2. Construa a string a ser assinada: A string a ser assinada é a base para criar uma assinatura e inclui nela o valor de hash codificado em hexadecimal da solicitação canônica.

    Consulte Assinaturas para obter detalhes sobre o formato da string a ser assinada.

  3. Assine a string usando uma assinatura RSA com SHA-256. O resultado dessa assinatura é sua assinatura de solicitação.

    A linguagem de programação precisa de uma biblioteca para executar assinaturas RSA. Como alternativa, é possível usar o método IAMsignBlob fornecido pelo Google Cloud se o prazo de validade for de 12 horas ou menos.

  4. Construa o URL assinado usando a seguinte concatenação:

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

    O URL assinado tem os seguintes componentes:

    • HOSTNAME: deve ser https://storage.googleapis.com.

    • PATH_TO_RESOURCE: precisa corresponder ao valor usado na construção da solicitação canônica.

    • CANONICAL_QUERY_STRING: precisa corresponder aos valores usados na construção da solicitação canônica.

    • REQUEST_SIGNATURE: é a saída do uso de uma assinatura RSA na etapa anterior.

    Veja um exemplo de URL completo:

    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

Programa de amostra em Python

É possível usar as bibliotecas de cliente do Cloud Storage para criar URLs assinados para muitas linguagens de programação comuns. Consulte Processo de assinatura V4 com ferramentas do Cloud Storage para ver exemplos.

O exemplo a seguir mostra uma implementação do algoritmo para assinar URLs que não usam as bibliotecas de cliente do Cloud Storage. A amostra usa a linguagem de programação Python, mas pode ser adaptada à linguagem de sua escolha.

storage/signed_urls/generate_signed_urls.py 
import binascii
import collections
import datetime
import hashlib
import sys

# pip install google-auth
from google.oauth2 import service_account
# pip install six
import six
from six.moves.urllib.parse import quote

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 = '/{}'.format(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 = '{}/auto/storage/goog4_request'.format(datestamp)
    credential = '{}/{}'.format(client_email, credential_scope)

    if headers is None:
        headers = dict()
    host = '{}.storage.googleapis.com'.format(bucket_name)
    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 += '{}:{}\n'.format(lower_k, strip_v)

    signed_headers = ''
    for k, _ in ordered_headers.items():
        lower_k = str(k).lower()
        signed_headers += '{};'.format(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 += '{}={}&'.format(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

A seguir