public static async Task Run(MinioClient client,
                                 string bucketName = "my-bucketname",
                                 string objectName = "my-objectname")
    {
        // default value for expiration is 2 minutes
        var expiration = DateTime.UtcNow.AddMinutes(2);

        var form = new PostPolicy();

        form.SetKey(objectName);
        form.SetBucket(bucketName);
        form.SetExpires(expiration);

        var args = new PresignedPostPolicyArgs()
                   .WithBucket(bucketName)
                   .WithObject(objectName)
                   .WithPolicy(form);

        var tuple = await client.PresignedPostPolicyAsync(form);

        var curlCommand = "curl -k --insecure -X POST";

        foreach (var pair in tuple.Item2)
        {
            curlCommand = curlCommand + $" -F {pair.Key}={pair.Value}";
        }
        curlCommand = curlCommand + " -F file=@/etc/issue " + tuple.Item1 + bucketName + "/";
    }
Esempio n. 2
0
        public async static Task Run(MinioClient client)
        {
            try
            {
                PostPolicy form       = new PostPolicy();
                DateTime   expiration = DateTime.UtcNow;
                form.SetExpires(expiration.AddDays(10));
                form.SetKey("my-objectname");
                form.SetBucket("my-bucketname");

                Tuple <string, Dictionary <string, string> > tuple = await client.PresignedPostPolicyAsync(form);

                string curlCommand = "curl -X POST ";
                foreach (KeyValuePair <string, string> pair in tuple.Item2)
                {
                    curlCommand = curlCommand + String.Format(" -F {0}={1}", pair.Key, pair.Value);
                }
                curlCommand = curlCommand + " -F file=@/etc/bashrc " + tuple.Item1; // https://s3.amazonaws.com/my-bucketname";
                Console.Out.WriteLine(curlCommand);
            }
            catch (Exception e)
            {
                Console.Out.WriteLine("Exception ", e.Message);
            }
        }
Esempio n. 3
0
        public async Task <AddPolicyResponse> ExecuteAsync(PostPolicy request, string url, string authorizationHeaderValue)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            if (string.IsNullOrWhiteSpace(url))
            {
                throw new ArgumentNullException(nameof(url));
            }

            if (string.IsNullOrWhiteSpace(authorizationHeaderValue))
            {
                throw new ArgumentNullException(nameof(authorizationHeaderValue));
            }

            var httpClient = _httpClientFactory.GetHttpClient();
            var serializedPostResourceSet = JsonConvert.SerializeObject(request);
            var body        = new StringContent(serializedPostResourceSet, Encoding.UTF8, "application/json");
            var httpRequest = new HttpRequestMessage
            {
                Content    = body,
                Method     = HttpMethod.Post,
                RequestUri = new Uri(url)
            };

            httpRequest.Headers.Add("Authorization", "Bearer " + authorizationHeaderValue);
            var httpResult = await httpClient.SendAsync(httpRequest).ConfigureAwait(false);

            httpResult.EnsureSuccessStatusCode();
            var content = await httpResult.Content.ReadAsStringAsync().ConfigureAwait(false);

            return(JsonConvert.DeserializeObject <AddPolicyResponse>(content));
        }
Esempio n. 4
0
 internal SignedPostPolicy(PostPolicy source, string encodedPolicy, string signature, DateTimeOffset expiration, Uri url)
 {
     Source        = GaxPreconditions.CheckNotNull(source, nameof(source));
     PostUrl       = GaxPreconditions.CheckNotNull(url, nameof(url));
     EncodedPolicy = GaxPreconditions.CheckNotNull(encodedPolicy, nameof(encodedPolicy));
     Signature     = GaxPreconditions.CheckNotNull(signature, nameof(signature));
     Expiration    = expiration;
 }
Esempio n. 5
0
            public SignedPostPolicy Sign(PostPolicy postPolicy, Options options, IBlobSigner blobSigner, IClock clock)
            {
                var state           = new PostPolicySigningState(new PostPolicy(postPolicy), options, blobSigner, clock);
                var base64Signature = blobSigner.CreateSignature(state._blobToSign);
                var rawSignature    = Convert.FromBase64String(base64Signature);
                var hexSignature    = FormatHex(rawSignature);

                return(state.GetResult(hexSignature));
            }
Esempio n. 6
0
                internal PostPolicySigningState(PostPolicy policy, Options options, IBlobSigner blobSigner, IClock clock)
                {
                    string uri = options.UrlStyle switch
                    {
                        UrlStyle.PathStyle => policy.Bucket == null ? StorageHost : $"{StorageHost}/{policy.Bucket}",
                        UrlStyle.VirtualHostedStyle => policy.Bucket == null ?
                        throw new ArgumentNullException(nameof(PostPolicy.Bucket), $"When using {UrlStyle.VirtualHostedStyle} a bucket condition must be set in the policy.") :
                              $"{policy.Bucket}.{StorageHost}",
                              UrlStyle.BucketBoundHostname => options.BucketBoundHostname,
                              _ => throw new ArgumentOutOfRangeException(nameof(options.UrlStyle))
                    };

                    uri = $"{options.Scheme}://{uri}/";

                    options = options.ToExpiration(clock);
                    var now = clock.GetCurrentDateTimeUtc();

                    int expirySeconds = (int)(options.Expiration.Value - now).TotalSeconds;

                    if (expirySeconds <= 0)
                    {
                        throw new ArgumentOutOfRangeException(nameof(options.Expiration), "Expiration must be at least 1 second.");
                    }
                    if (expirySeconds > MaxExpirySecondsInclusive)
                    {
                        throw new ArgumentOutOfRangeException(nameof(options.Expiration), "Expiration must not be greater than 7 days.");
                    }

                    var    datestamp       = now.ToString("yyyyMMdd", CultureInfo.InvariantCulture);
                    string credentialScope = $"{datestamp}/{DefaultRegion}/{ScopeSuffix}";

                    policy.SetField(PolicyCreationDateTime.Element, new DateTimeOffset(now));
                    policy.SetField(PolicyAlgorithm.Element, Algorithm);
                    policy.SetField(PolicyCredential.Element, $"{blobSigner.Id}/{credentialScope}");

                    _expiration = options.Expiration.Value;
                    _policy     = policy;
                    _url        = new Uri(uri);

                    StringBuilder sb = new StringBuilder();
                    StringWriter  sw = new StringWriter(sb);

                    using (JsonWriter writer = new JsonTextWriter(sw))
                    {
                        writer.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;
                        writer.WriteStartObject();
                        policy.WriteTo(writer);
                        writer.WritePropertyName("expiration");
                        writer.WriteValue(_expiration.UtcDateTime.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture));
                        writer.WriteEndObject();
                    }

                    var decodedPolicy = sb.ToString();

                    _encodedPolicy = Convert.ToBase64String(Encoding.UTF8.GetBytes(decodedPolicy));
                    _blobToSign    = Encoding.UTF8.GetBytes(_encodedPolicy);
                }
Esempio n. 7
0
            public async Task <SignedPostPolicy> SignAsync(PostPolicy postPolicy, Options options, IBlobSigner blobSigner, IClock clock, CancellationToken cancellationToken)
            {
                var state           = new PostPolicySigningState(new PostPolicy(postPolicy), options, blobSigner, clock);
                var base64Signature = await blobSigner.CreateSignatureAsync(state._blobToSign, cancellationToken).ConfigureAwait(false);

                var rawSignature = Convert.FromBase64String(base64Signature);
                var hexSignature = FormatHex(rawSignature);

                return(state.GetResult(hexSignature));
            }
            public async void Unsupported_SignPostPolicy()
            {
                var signer  = UrlSigner.FromServiceAccountCredential(CreateFakeServiceAccountCredential());
                var options = Options
                              .FromExpiration(DateTimeOffset.UtcNow + TimeSpan.FromDays(1))
                              .WithSigningVersion(SigningVersion.V2);
                var postPolicy = PostPolicy.ForBucketAndKey("my-bucket", "my-test-object");

                Assert.Throws <NotSupportedException>(() => signer.Sign(postPolicy, options));
                await Assert.ThrowsAsync <NotSupportedException>(() => signer.SignAsync(postPolicy, options));
            }
Esempio n. 9
0
        public static AddPolicyParameter ToParameter(this PostPolicy postPolicy)
        {
            var rules = postPolicy.Rules == null ? new List <AddPolicyRuleParameter>()
                : postPolicy.Rules.Select(r => r.ToParameter()).ToList();

            return(new AddPolicyParameter
            {
                Rules = rules,
                ResourceSetIds = postPolicy.ResourceSetIds
            });
        }
 public static AddPolicyParameter ToParameter(this PostPolicy postPolicy)
 {
     return(new AddPolicyParameter
     {
         Claims = postPolicy.Claims == null ? new List <AddClaimParameter>() : postPolicy.Claims.Select(c => c.ToParameter()).ToList(),
         IsResourceOwnerConsentNeeded = postPolicy.IsResourceOwnerConsentNeeded,
         Script = postPolicy.Script,
         ResourceSetIds = postPolicy.ResourceSetIds,
         Scopes = postPolicy.Scopes,
         ClientIdsAllowed = postPolicy.ClientIdsAllowed
     });
 }
        public async Task <ActionResult> PostPolicy([FromBody] PostPolicy postPolicy)
        {
            if (postPolicy == null)
            {
                return(BuildError(ErrorCodes.InvalidRequestCode, "no parameter in body request", HttpStatusCode.BadRequest));
            }

            var policyId = await _policyActions.AddPolicy(postPolicy.ToParameter());

            var content = new AddPolicyResponse
            {
                PolicyId = policyId
            };

            return(new ObjectResult(content)
            {
                StatusCode = (int)HttpStatusCode.Created
            });
        }
Esempio n. 12
0
        public async Task <ActionResult> PostPolicy([FromBody] PostPolicy postPolicy)
        {
            if (postPolicy == null)
            {
                throw new ArgumentNullException(nameof(postPolicy));
            }

            var policyId = await _policyActions.AddPolicy(postPolicy.ToParameter());

            var content = new AddPolicyResponse
            {
                PolicyId = policyId
            };

            await _representationManager.AddOrUpdateRepresentationAsync(this, CachingStoreNames.GetPoliciesStoreName, false);

            return(new ObjectResult(content)
            {
                StatusCode = (int)HttpStatusCode.Created
            });
        }
Esempio n. 13
0
        public async Task <string> GetPresignedUploadUrlAsync(DTOs.Uploads.FileInfo fileInfo)
        {
            string endpoint   = _config["AppSettings:S3Endpoint"];
            string apiKey     = _config["AppSettings:S3ApiKey"];
            string apiSecret  = _config["AppSettings:S3ApiSecret"];
            string bucketName = _config["AppSettings:S3BucketName"];

            PostPolicy policy    = new PostPolicy();
            DateTime   expiredIn = DateTime.UtcNow.AddMinutes(15);

            policy.SetExpires(expiredIn);
            policy.SetContentLength(fileInfo.Size);
            policy.SetcontentType(fileInfo.ContentType);
            policy.SetKey(fileInfo.Name);
            policy.SetBucket(bucketName);

            var minio = new MinioClient(endpoint, apiKey, apiSecret);
            await minio.PresignedPostPolicyAsync(policy);

            string presignedUrl = await minio.PresignedPutObjectAsync(bucketName, fileInfo.Name, 15 * 60);

            return(presignedUrl);
        }
Esempio n. 14
0
        static int Main()
        {
            /// Note: YOUR-ACCESSKEYID, YOUR-SECRETACCESSKEY, my-bucketname and
            /// my-objectname are dummy values, please replace them with original values.
            var        client     = new MinioClient("s3.amazonaws.com", "YOUR-ACCESSKEYID", "YOUR-SECRETACCESSKEY");
            PostPolicy form       = new PostPolicy();
            DateTime   expiration = DateTime.UtcNow;

            form.SetExpires(expiration.AddDays(10));
            form.SetKey("my-objectname");
            form.SetBucket("my-bucketname");

            Dictionary <string, string> formData = client.PresignedPostPolicy(form);
            string curlCommand = "curl ";

            foreach (KeyValuePair <string, string> pair in formData)
            {
                curlCommand = curlCommand + " -F " + pair.Key + "=" + pair.Value;
            }
            curlCommand = curlCommand + " -F file=@/etc/bashrc https://s3.amazonaws.com/my-bucketname";
            Console.Out.WriteLine(curlCommand);
            return(0);
        }
Esempio n. 15
0
        public async static Task Run(MinioClient client,
                                     string bucketName = "my-bucketname",
                                     string objectName = "my-objectname")
        {
            // default value for expiration is 2 minutes
            DateTime expiration = DateTime.UtcNow.AddMinutes(2);

            // DefaultPolicy defaultPolicy = delegate (string bucketName,
            //                                         string objectName,
            //                                         DateTime expiration)
            // {
            PostPolicy form = new PostPolicy();

            form.SetKey(objectName);
            form.SetBucket(bucketName);
            form.SetExpires(expiration);
            // return policy;
            // };
            // PostPolicy postPolicy = defaultPolicy(bucketName,
            //                                       objectName,
            //                                       expiration);

            PresignedPostPolicyArgs args = new PresignedPostPolicyArgs()
                                           .WithBucket(bucketName)
                                           .WithObject(objectName)
                                           .WithPolicy(form);

            var tuple = await client.PresignedPostPolicyAsync(form);

            string curlCommand = "curl -k --insecure -X POST";

            foreach (KeyValuePair <string, string> pair in tuple.Item2)
            {
                curlCommand = curlCommand + $" -F {pair.Key}={pair.Value}";
            }
            curlCommand = curlCommand + " -F file=@/etc/issue " + tuple.Item1 + bucketName + "/";
        }
        static int Main()
        {
            /// Note: s3 AccessKey and SecretKey needs to be added in App.config file
            /// See instructions in README.md on running examples for more information.
            var client = new MinioClient("s3.amazonaws.com", ConfigurationManager.AppSettings["s3AccessKey"],
                                         ConfigurationManager.AppSettings["s3SecretKey"]);
            PostPolicy form       = new PostPolicy();
            DateTime   expiration = DateTime.UtcNow;

            form.SetExpires(expiration.AddDays(10));
            form.SetKey("my-objectname");
            form.SetBucket("my-bucketname");

            Dictionary <string, string> formData = client.PresignedPostPolicy(form);
            string curlCommand = "curl ";

            foreach (KeyValuePair <string, string> pair in formData)
            {
                curlCommand = curlCommand + " -F " + pair.Key + "=" + pair.Value;
            }
            curlCommand = curlCommand + " -F file=@/etc/bashrc https://s3.amazonaws.com/my-bucketname";
            Console.Out.WriteLine(curlCommand);
            return(0);
        }
Esempio n. 17
0
        public void TestPresignedPostPolicy()
        {
            DateTime requestDate   = new DateTime(2020, 05, 01, 15, 45, 33, DateTimeKind.Utc);
            var      authenticator = new V4Authenticator(false, "my-access-key", "secretkey");

            var policy = new PostPolicy();

            policy.SetBucket("bucket-name");
            policy.SetKey("object-name");

            policy.SetAlgorithm("AWS4-HMAC-SHA256");
            var region = "mock-location";

            policy.SetCredential(authenticator.GetCredentialString(requestDate, region));
            policy.SetDate(requestDate);
            policy.SetSessionToken(null);

            string policyBase64 = policy.Base64();
            string signature    = authenticator.PresignPostSignature(region, requestDate, policyBase64);

            policy.SetPolicy(policyBase64);
            policy.SetSignature(signature);

            var headers = new Dictionary <string, string>
            {
                { "bucket", "bucket-name" },
                { "key", "object-name" },
                { "x-amz-algorithm", "AWS4-HMAC-SHA256" },
                { "x-amz-credential", "my-access-key/20200501/mock-location/s3/aws4_request" },
                { "x-amz-date", "20200501T154533Z" },
                { "policy", "eyJleHBpcmF0aW9uIjoiMDAwMS0wMS0wMVQwMDowMDowMC4wMDBaIiwiY29uZGl0aW9ucyI6W1siZXEiLCIkYnVja2V0IiwiYnVja2V0LW5hbWUiXSxbImVxIiwiJGtleSIsIm9iamVjdC1uYW1lIl0sWyJlcSIsIiR4LWFtei1hbGdvcml0aG0iLCJBV1M0LUhNQUMtU0hBMjU2Il0sWyJlcSIsIiR4LWFtei1jcmVkZW50aWFsIiwibXktYWNjZXNzLWtleS8yMDIwMDUwMS9tb2NrLWxvY2F0aW9uL3MzL2F3czRfcmVxdWVzdCJdLFsiZXEiLCIkeC1hbXotZGF0ZSIsIjIwMjAwNTAxVDE1NDUzM1oiXV19" },
                { "x-amz-signature", "ec6dad862909ee905cfab3ef87ede0e666eebd6b8f00d28e5df104a8fcbd4027" },
            };

            CollectionAssert.AreEquivalent(headers, policy.GetFormData());
        }
Esempio n. 18
0
        private async static Task PresignedPostPolicy_Test1(MinioClient minio)
        {
            Console.Out.WriteLine("Test1: PresignedPostPolicyAsync");
            string bucketName = GetRandomName(15);
            string objectName = GetRandomName(10);
            string fileName   = CreateFile(1 * MB);


            try
            {
                await Setup_Test(minio, bucketName);

                await minio.PutObjectAsync(bucketName,
                                           objectName,
                                           fileName);

                // Generate presigned post policy url
                PostPolicy form       = new PostPolicy();
                DateTime   expiration = DateTime.UtcNow;
                form.SetExpires(expiration.AddDays(10));
                form.SetKey(objectName);
                form.SetBucket(bucketName);
                var    pairs = new List <KeyValuePair <string, string> >();
                string url   = "https://s3.amazonaws.com/" + bucketName;
                Tuple <string, System.Collections.Generic.Dictionary <string, string> > policyTuple = await minio.PresignedPostPolicyAsync(form);

                var httpClient = new HttpClient();

                using (var stream = File.OpenRead(fileName))
                {
                    MultipartFormDataContent multipartContent = new MultipartFormDataContent();
                    multipartContent.Add(new StreamContent(stream), fileName, objectName);
                    multipartContent.Add(new FormUrlEncodedContent(pairs));
                    var response = await httpClient.PostAsync(url, multipartContent);

                    response.EnsureSuccessStatusCode();
                }

                // Validate
                PolicyType policy = await minio.GetPolicyAsync(bucketName, objectName.Substring(5));

                Assert.AreEqual(policy.GetType(), PolicyType.READ_ONLY);
                await minio.RemoveObjectAsync(bucketName, objectName);

                await TearDown(minio, bucketName);

                File.Delete(fileName);
            }
            catch (Exception e)
            {
                Console.Out.WriteLine("Exception ", e.Message);
            }

            Console.Out.WriteLine("Test1: PresignedPostPolicyAsync Complete");


            await minio.RemoveObjectAsync(bucketName, objectName);

            await TearDown(minio, bucketName);

            File.Delete(fileName);
            Console.Out.WriteLine("Test1: PresignedPostPolicyAsync Complete");
        }
Esempio n. 19
0
        public async Task <AddPolicyResult> AddByResolution(PostPolicy request, string url, string token)
        {
            var policyEndpoint = await GetPolicyEndPoint(UriHelpers.GetUri(url)).ConfigureAwait(false);

            return(await Add(request, policyEndpoint, token).ConfigureAwait(false));
        }
Esempio n. 20
0
        public void PostPolicyTest(PostPolicyV4Test test)
        {
            var timestamp = test.PolicyInput.Timestamp.ToDateTime();
            var clock     = new FakeClock(timestamp);
            var signer    = UrlSigner
                            .FromServiceAccountCredential(StorageConformanceTestData.TestCredential)
                            .WithClock(clock);

            var options = Options
                          .FromDuration(TimeSpan.FromSeconds(test.PolicyInput.Expiration))
                          .WithSigningVersion(SigningVersion.V4)
                          .WithScheme(test.PolicyInput.Scheme);

            switch (test.PolicyInput.UrlStyle)
            {
            case UrlStyle.VirtualHostedStyle:
                options = options.WithUrlStyle(UrlSigner.UrlStyle.VirtualHostedStyle);
                break;

            case UrlStyle.BucketBoundHostname:
                options = options.WithBucketBoundHostname(test.PolicyInput.BucketBoundHostname);
                break;

            default:
                break;
            }

            var postPolicy = PostPolicy.ForBucketAndKey(test.PolicyInput.Bucket, test.PolicyInput.Object, new PostPolicyElementTestComparer());

            foreach (var field in test.PolicyInput.Fields)
            {
                if (field.Key.StartsWith("x-goog-meta-"))
                {
                    postPolicy.SetCustomField(PostPolicyCustomElement.GoogleMetadata, field.Key, field.Value);
                }
                else
                {
                    var element = GetStandardElement(field.Key);
                    if (element == PostPolicyStandardElement.SuccessActionStatus)
                    {
                        postPolicy.SetField(element, (HttpStatusCode)int.Parse(field.Value));
                    }
                    else
                    {
                        postPolicy.SetField(element, field.Value);
                    }
                }
            }

            for (int i = 0; i < test.PolicyInput.Conditions?.StartsWith?.Count; i += 2)
            {
                postPolicy.SetStartsWith(
                    GetStandardElement(test.PolicyInput.Conditions.StartsWith[i]),
                    test.PolicyInput.Conditions.StartsWith[i + 1]);
            }

            if (test.PolicyInput.Conditions?.ContentLengthRange?.Count > 0)
            {
                postPolicy.SetRange(PostPolicyStandardElement.ContentLength, test.PolicyInput.Conditions.ContentLengthRange[0], test.PolicyInput.Conditions.ContentLengthRange[1]);
            }

            var signedPostPolicy = signer.Sign(postPolicy, options);

            Assert.Equal(test.PolicyOutput.Url, signedPostPolicy.PostUrl.ToString());

            Assert.Equal(test.PolicyOutput.Fields.Count, signedPostPolicy.Fields.Count);
            foreach (var field in test.PolicyOutput.Fields)
            {
                Assert.True(signedPostPolicy.Fields.TryGetValue(field.Key, out object value));
                Assert.Equal(field.Value, value.ToString());
            }

            PostPolicyStandardElement GetStandardElement(string name) =>
            name switch
            {
                "acl" => PostPolicyStandardElement.Acl,
                "$acl" => PostPolicyStandardElement.Acl,
                "cache-control" => PostPolicyStandardElement.CacheControl,
                "$cache-control" => PostPolicyStandardElement.CacheControl,
                "success_action_status" => PostPolicyStandardElement.SuccessActionStatus,
                "$success_action_status" => PostPolicyStandardElement.SuccessActionStatus,
                "success_action_redirect" => PostPolicyStandardElement.SuccessActionRedirect,
                "$success_action_redirect" => PostPolicyStandardElement.SuccessActionRedirect,
                "content-disposition" => PostPolicyStandardElement.ContentDisposition,
                "$content-disposition" => PostPolicyStandardElement.ContentDisposition,
                "content-encoding" => PostPolicyStandardElement.ContentEncoding,
                "$content-encoding" => PostPolicyStandardElement.ContentEncoding,
                "content-type" => PostPolicyStandardElement.ContentType,
                _ => throw new NotImplementedException($"{name} missing from {nameof(GetStandardElement)}.")
            };
        }
 internal PostPolicy(PostPolicy other) =>
 public Task <SignedPostPolicy> SignAsync(PostPolicy postPolicy, Options options, IBlobSigner blobSigner, IClock clock, CancellationToken cancellationToken) =>
 throw new NotSupportedException($"Post policy signing is not supported by {nameof(SigningVersion)}.{SigningVersion.V2}.");
Esempio n. 23
0
 /// <summary>
 /// Signs the given post policy. The result can be used to make form posting requests matching the conditions
 /// set in the post policy.
 /// </summary>
 /// <remarks>
 /// <para>
 /// Signing post policies is not supported by <see cref="SigningVersion.V2"/>. A <see cref="NotSupportedException"/>
 /// will be thrown if an attempt is made to sign a post policy using <see cref="SigningVersion.V2"/>.
 /// </para>
 /// <para>
 /// When a <see cref="UrlSigner"/> is created with a service account credential, the signing can be performed
 /// with no network access. When it is created with an implementation of <see cref="IBlobSigner"/>, that may require
 /// network access or other IO. In that case, one of the asynchronous methods should be used when the caller is
 /// in a context that should not block.
 /// </para>
 /// <para>
 /// See https://cloud.google.com/storage/docs/xml-api/post-object for more information on signed post policies.
 /// </para>
 /// </remarks>
 /// <param name="postPolicy">The post policy to signed and that will be enforced when making the post request.
 /// Most not be null.</param>
 /// <param name="options">The options used to generate the signed post policy. Must not be null.</param>
 /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
 /// <returns>The signed post policy, which contains all the fields that should be including in the form to post.</returns>
 public Task <SignedPostPolicy> SignAsync(PostPolicy postPolicy, Options options, CancellationToken cancellationToken = default) =>
 GetEffectiveSigner(GaxPreconditions.CheckNotNull(options, nameof(options)).SigningVersion).SignAsync(
     GaxPreconditions.CheckNotNull(postPolicy, nameof(postPolicy)), options, _blobSigner, _clock, cancellationToken);
Esempio n. 24
0
 /// <summary>
 /// Signs the given post policy. The result can be used to make form posting requests matching the conditions
 /// set in the post policy.
 /// </summary>
 /// <remarks>
 /// <para>
 /// Signing post policies is not supported by <see cref="SigningVersion.V2"/>. A <see cref="NotSupportedException"/>
 /// will be thrown if an attempt is made to sign a post policy using <see cref="SigningVersion.V2"/>.
 /// </para>
 /// <para>
 /// When a <see cref="UrlSigner"/> is created with a service account credential, the signing can be performed
 /// with no network access. When it is created with an implementation of <see cref="IBlobSigner"/>, that may require
 /// network access or other IO. In that case, one of the asynchronous methods should be used when the caller is
 /// in a context that should not block.
 /// </para>
 /// <para>
 /// See https://cloud.google.com/storage/docs/xml-api/post-object for more information on signed post policies.
 /// </para>
 /// </remarks>
 /// <param name="postPolicy">The post policy to signed and that will be enforced when making the post request.
 /// Must not be null.</param>
 /// <param name="options">The options used to generate the signed post policy. Must not be null.</param>
 /// <returns>The signed post policy, which contains all the fields that should be including in the form to post.</returns>
 public SignedPostPolicy Sign(PostPolicy postPolicy, Options options) =>
 GetEffectiveSigner(GaxPreconditions.CheckNotNull(options, nameof(options)).SigningVersion).Sign(
     GaxPreconditions.CheckNotNull(postPolicy, nameof(postPolicy)), options, _blobSigner, _clock);
 public Task <AddPolicyResponse> Add(PostPolicy request, string url, string token)
 {
     return(_addPolicyOperation.ExecuteAsync(request, url, token));
 }
        public async Task <AddPolicyResponse> AddByResolution(PostPolicy request, string url, string token)
        {
            var policyEndpoint = await GetPolicyEndPoint(UriHelpers.GetUri(url));

            return(await Add(request, policyEndpoint, token));
        }
 public SignedPostPolicy Sign(PostPolicy postPolicy, Options options, IBlobSigner blobSigner, IClock clock) =>
 throw new NotSupportedException($"Post policy signing is not supported by {nameof(SigningVersion)}.{SigningVersion.V2}.");