Processo de assinatura V4 com seu próprio programa

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. Os URLs assinados fornecem acesso de leitura ou gravação por tempo limitado a um recurso específico do Cloud Storage. Qualquer pessoa que tiver o URL assinado poderá usá-lo enquanto ele estiver ativo, mesmo sem uma conta do Google.

Para saber como usar as ferramentas do Cloud Storage para criar mais facilmente URLs assinados com chave RSA do Cloud Storage, consulte Processo de assinatura da V4 com as Ferramentas do Cloud Storage. Para saber mais sobre URLs assinados, consulte a Visão geral de URLs assinados.

Pré-requisitos

Antes de criar um programa que implemente o processo de assinatura 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. Conceder à 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. Outra opção é usar o método signBlob do IAM fornecido pelo Google Cloud se o prazo de expiração 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.

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.utcnow()
    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