feature: V4 Post policies

google/cloud/storage/_signing.py

@@ -531,9 +531,7 @@ def generate_signed_url_v4(
  expiration_seconds = get_expiration_seconds_v4(expiration)
 
  if _request_timestamp is None:
- now = NOW()
- request_timestamp = now.strftime("%Y%m%dT%H%M%SZ")
- datestamp = now.date().strftime("%Y%m%d")
+ request_timestamp, datestamp = get_v4_now_dtstamps()
  else:
  request_timestamp = _request_timestamp
  datestamp = _request_timestamp[:8]
@@ -629,6 +627,18 @@ def generate_signed_url_v4(
  )
 
 
+def get_v4_now_dtstamps():
+ """Get current timestamp and datestamp in V4 valid format.
+
+ :rtype: str, str
+ :returns: Current timestamp, datestamp.
+ """
+ now = NOW()
+ timestamp = now.strftime("%Y%m%dT%H%M%SZ")
+ datestamp = now.date().strftime("%Y%m%d")
+ return timestamp, datestamp
+
+
 def _sign_message(message, access_token, service_account_email):
 
  """Signs a message.

google/cloud/storage/client.py

@@ -14,18 +14,28 @@
 
 """Client for interacting with the Google Cloud Storage API."""
 
-import warnings
+import base64
+import binascii
+import datetime
 import functools
+import json
+import warnings
 import google.api_core.client_options
 
 from google.auth.credentials import AnonymousCredentials
 
 from google.api_core import page_iterator
-from google.cloud._helpers import _LocalStack
+from google.cloud._helpers import _LocalStack, _NOW
 from google.cloud.client import ClientWithProject
 from google.cloud.exceptions import NotFound
 from google.cloud.storage._helpers import _get_storage_host
 from google.cloud.storage._http import Connection
+from google.cloud.storage._signing import (
+ get_expiration_seconds_v4,
+ get_v4_now_dtstamps,
+ ensure_signed_credentials,
+ _sign_message,
+)
 from google.cloud.storage.batch import Batch
 from google.cloud.storage.bucket import Bucket
 from google.cloud.storage.blob import Blob
@@ -836,6 +846,174 @@ def get_hmac_key_metadata(
  metadata.reload(timeout=timeout) # raises NotFound for missing key
  return metadata
 
+ def generate_signed_post_policy_v4(
+ self,
+ bucket_name,
+ blob_name,
+ expiration,
+ conditions=None,
+ fields=None,
+ credentials=None,
+ virtual_hosted_style=False,
+ bucket_bound_hostname=None,
+ scheme=None,
+ service_account_email=None,
+ access_token=None,
+ ):
+ """Generate a V4 signed policy object.
+
+ .. note::
+
+ Assumes ``credentials`` implements the
+ :class:`google.auth.credentials.Signing` interface. Also assumes
+ ``credentials`` has a ``service_account_email`` property which
+ identifies the credentials.
+
+ Generated policy object allows user to upload objects with a POST request.
+
+ :type bucket_name: str
+ :param bucket_name: Bucket name.
+
+ :type blob_name: str
+ :param blob_name: Object name.
+
+ :type expiration: Union[Integer, datetime.datetime, datetime.timedelta]
+ :param expiration: Policy expiration time.
+
+ :type conditions: list
+ :param conditions: (Optional) List of POST policy conditions, which are
+ used to restrict what is allowed in the request.
+
+ :type fields: dict
+ :param fields: (Optional) Additional elements to include into request.
+
+ :type credentials: :class:`google.auth.credentials.Signing`
+ :param credentials: (Optional) Credentials object with an associated private
+ key to sign text.
+
+ :type virtual_hosted_style: bool
+ :param virtual_hosted_style: (Optional) If True, construct the URL relative to the bucket
+ virtual hostname, e.g., '<bucket-name>.storage.googleapis.com'.
+
+ :type bucket_bound_hostname: str
+ :param bucket_bound_hostname:
+ (Optional) If passed, construct the URL relative to the bucket-bound hostname.
+ Value can be bare or with a scheme, e.g., 'example.com' or 'http://example.com'.
+ See: https://cloud.google.com/storage/docs/request-endpoints#cname
+
+ :type scheme: str
+ :param scheme:
+ (Optional) If ``bucket_bound_hostname`` is passed as a bare hostname, use
+ this value as a scheme. ``https`` will work only when using a CDN.
+ Defaults to ``"http"``.
+
+ :type service_account_email: str
+ :param service_account_email: (Optional) E-mail address of the service account.
+
+ :type access_token: str
+ :param access_token: (Optional) Access token for a service account.
+
+ :rtype: dict
+ :returns: Signed POST policy.
+
+ Example:
+ Generate signed POST policy and upload a file.
+
+ >>> from google.cloud import storage
+ >>> client = storage.Client()
+ >>> policy = client.generate_signed_post_policy_v4(
+ "bucket-name",
+ "blob-name",
+ expiration=datetime.datetime(2020, 3, 17),
+ conditions=[
+ ["content-length-range", 0, 255]
+ ],
+ fields=[
+ "x-goog-meta-hello" => "world"
+ ],
+ )
+ >>> with open("bucket-name", "rb") as f:
+ files = {"file": ("bucket-name", f)}
+ requests.post(policy["url"], data=policy["fields"], files=files)
+ """
+ credentials = self._credentials if credentials is None else credentials
+ ensure_signed_credentials(credentials)
+
+ # prepare policy conditions and fields
+ timestamp, datestamp = get_v4_now_dtstamps()
+
+ x_goog_credential = "{email}/{datestamp}/auto/storage/goog4_request".format(
+ email=credentials.signer_email, datestamp=datestamp
+ )
+ required_conditions = [
+ {"key": blob_name},
+ {"x-goog-date": timestamp},
+ {"x-goog-credential": x_goog_credential},
+ {"x-goog-algorithm": "GOOG4-RSA-SHA256"},
+ ]
+
+ conditions = conditions or []
+ policy_fields = {}
+ for key, value in sorted((fields or {}).items()):
+ if not key.startswith("x-ignore-"):
+ policy_fields[key] = value
+ conditions.append({key: value})
+
+ conditions += required_conditions
+
+ # calculate policy expiration time
+ now = _NOW()
+ if expiration is None:
+ expiration = now + datetime.timedelta(hours=1)
+
+ policy_expires = now + datetime.timedelta(
+ seconds=get_expiration_seconds_v4(expiration)
+ )
+
+ # encode policy for signing
+ policy = json.dumps(
+ {"conditions": conditions, "expiration": policy_expires.isoformat() + "Z"},
+ separators=(",", ":"),
+ )
+ str_to_sign = base64.b64encode(policy.encode("utf-8"))
+
+ # sign the policy and get its cryptographic signature
+ if access_token and service_account_email:
+ signature = _sign_message(str_to_sign, access_token, service_account_email)
+ signature_bytes = base64.b64decode(signature)
+ else:
+ signature_bytes = credentials.sign_bytes(str_to_sign)
+
+ # get hexadecimal representation of the signature
+ signature = binascii.hexlify(signature_bytes).decode("utf-8")
+
+ policy_fields.update(
+ {
+ "key": blob_name,
+ "x-goog-algorithm": "GOOG4-RSA-SHA256",
+ "x-goog-credential": x_goog_credential,
+ "x-goog-date": timestamp,
+ "x-goog-signature": signature,
+ "policy": str_to_sign,
+ }
+ )
+ # designate URL
+ if virtual_hosted_style:
+ url = "https://{}.storage.googleapis.com/".format(bucket_name)
+
+ elif bucket_bound_hostname:
+ if ":" in bucket_bound_hostname: # URL includes scheme
+ url = bucket_bound_hostname
+
+ else: # scheme is given separately
+ url = "{scheme}://{host}/".format(
+ scheme=scheme, host=bucket_bound_hostname
+ )
+ else:
+ url = "https://storage.googleapis.com/{}/".format(bucket_name)
+
+ return {"url": url, "fields": policy_fields}
+
 
 def _item_to_bucket(iterator, item):
  """Convert a JSON bucket to the native object.

tests/system/test_system.py

@@ -1955,3 +1955,67 @@ def test_ubla_set_unset_preserves_acls(self):
 
  self.assertEqual(bucket_acl_before, bucket_acl_after)
  self.assertEqual(blob_acl_before, blob_acl_after)
+
+
+class TestV4POSTPolicies(unittest.TestCase):
+ def setUp(self):
+ self.case_buckets_to_delete = []
+
+ def tearDown(self):
+ for bucket_name in self.case_buckets_to_delete:
+ bucket = Config.CLIENT.bucket(bucket_name)
+ retry_429_harder(bucket.delete)(force=True)
+
+ def test_get_signed_policy_v4(self):
+ bucket_name = "post_policy" + unique_resource_id("-")
+ self.assertRaises(exceptions.NotFound, Config.CLIENT.get_bucket, bucket_name)
+ retry_429_503(Config.CLIENT.create_bucket)(bucket_name)
+ self.case_buckets_to_delete.append(bucket_name)
+
+ blob_name = "post_policy_obj.txt"
+ with open(blob_name, "w") as f:
+ f.write("DEADBEEF")
+
+ policy = Config.CLIENT.generate_signed_post_policy_v4(
+ bucket_name,
+ blob_name,
+ conditions=[
+ {"bucket": bucket_name},
+ ["starts-with", "$Content-Type", "text/pla"],
+ ],
+ expiration=datetime.datetime.now() + datetime.timedelta(hours=1),
+ fields={"content-type": "text/plain"},
+ )
+ with open(blob_name, "r") as f:
+ files = {"file": (blob_name, f)}
+ response = requests.post(policy["url"], data=policy["fields"], files=files)
+
+ os.remove(blob_name)
+ self.assertEqual(response.status_code, 204)
+
+ def test_get_signed_policy_v4_invalid_field(self):
+ bucket_name = "post_policy" + unique_resource_id("-")
+ self.assertRaises(exceptions.NotFound, Config.CLIENT.get_bucket, bucket_name)
+ retry_429_503(Config.CLIENT.create_bucket)(bucket_name)
+ self.case_buckets_to_delete.append(bucket_name)
+
+ blob_name = "post_policy_obj.txt"
+ with open(blob_name, "w") as f:
+ f.write("DEADBEEF")
+
+ policy = Config.CLIENT.generate_signed_post_policy_v4(
+ bucket_name,
+ blob_name,
+ conditions=[
+ {"bucket": bucket_name},
+ ["starts-with", "$Content-Type", "text/pla"],
+ ],
+ expiration=datetime.datetime.now() + datetime.timedelta(hours=1),
+ fields={"x-goog-random": "invalid_field", "content-type": "text/plain"},
+ )
+ with open(blob_name, "r") as f:
+ files = {"file": (blob_name, f)}
+ response = requests.post(policy["url"], data=policy["fields"], files=files)
+
+ os.remove(blob_name)
+ self.assertEqual(response.status_code, 400)

tests/unit/__init__.py

@@ -11,3 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+import io
+import json
+import os
+
+
+def _read_local_json(json_file):
+ here = os.path.dirname(__file__)
+ json_path = os.path.abspath(os.path.join(here, json_file))
+ with io.open(json_path, "r", encoding="utf-8-sig") as fileobj:
+ return json.load(fileobj)

tests/unit/test__signing.py

@@ -18,9 +18,7 @@
 import binascii
 import calendar
 import datetime
-import io
 import json
-import os
 import time
 import unittest
 
@@ -29,12 +27,7 @@
 import six
 from six.moves import urllib_parse
 
-
-def _read_local_json(json_file):
- here = os.path.dirname(__file__)
- json_path = os.path.abspath(os.path.join(here, json_file))
- with io.open(json_path, "r", encoding="utf-8-sig") as fileobj:
- return json.load(fileobj)
+from . import _read_local_json
 
 
 _SERVICE_ACCOUNT_JSON = _read_local_json("url_signer_v4_test_account.json")
@@ -762,6 +755,22 @@ def test_bytes(self):
  self.assertEqual(encoded_param, "bytes")
 
 
+class TestV4Stamps(unittest.TestCase):
+ def test_get_v4_now_dtstamps(self):
+ import datetime
+ from google.cloud.storage._signing import get_v4_now_dtstamps
+
+ with mock.patch(
+ "google.cloud.storage._signing.NOW",
+ return_value=datetime.datetime(2020, 3, 12, 13, 14, 15),
+ ) as now_mock:
+ timestamp, datestamp = get_v4_now_dtstamps()
+ now_mock.assert_called_once()
+
+ self.assertEqual(timestamp, "20200312T131415Z")
+ self.assertEqual(datestamp, "20200312")
+
+
 _DUMMY_SERVICE_ACCOUNT = None