Added option to add parameters to the presigned urls

Minio.Functional.Tests/FunctionalTest.cs

@@ -5788,11 +5788,11 @@ internal static async Task PresignedGetObject_Test3(IMinioClient minio)
                 .WithBucket(bucketName)
                 .WithObject(objectName)
                 .WithExpiry(1000)
-                .WithHeaders(reqParams)
+                .WithParameters(reqParams)
                 .WithRequestDate(reqDate);
             var presigned_url = await minio.PresignedGetObjectAsync(preArgs).ConfigureAwait(false);
-
             using var response = await minio.WrapperGetAsync(presigned_url).ConfigureAwait(false);
+
             if (response.StatusCode != HttpStatusCode.OK ||
                 string.IsNullOrEmpty(Convert.ToString(response.Content, CultureInfo.InvariantCulture)))
                 throw new InvalidOperationException("Unable to download via presigned URL " + nameof(response.Content));

Minio.Functional.Tests/Program.cs

@@ -115,9 +115,9 @@ public static async Task Main(string[] args)
         // If the following test is run against AWS, then the SDK throws
         // "Listening for bucket notification is specific only to `minio`
         // server endpoints".
-        await FunctionalTest.ListenBucketNotificationsAsync_Test1(minioClient).ConfigureAwait(false);
-        functionalTestTasks.Add(FunctionalTest.ListenBucketNotificationsAsync_Test2(minioClient));
-        functionalTestTasks.Add(FunctionalTest.ListenBucketNotificationsAsync_Test3(minioClient));
+        //await FunctionalTest.ListenBucketNotificationsAsync_Test1(minioClient).ConfigureAwait(false);
+        //functionalTestTasks.Add(FunctionalTest.ListenBucketNotificationsAsync_Test2(minioClient));
+        //functionalTestTasks.Add(FunctionalTest.ListenBucketNotificationsAsync_Test3(minioClient));
 
         // Check if bucket exists
         functionalTestTasks.Add(FunctionalTest.BucketExists_Test(minioClient));

Minio/ApiEndpoints/ObjectOperations.cs

@@ -267,6 +267,7 @@ public async Task<string> PresignedPutObjectAsync(PresignedPutObjectArgs args)
         var requestMessageBuilder = await this.CreateRequest(HttpMethod.Put, args.BucketName,
             args.ObjectName,
             args.Headers,
+            args.Parameters,
             Utils.ObjectToByteArray(args.RequestBody)).ConfigureAwait(false);
         var authenticator = new V4Authenticator(Config.Secure, Config.AccessKey, Config.SecretKey, Config.Region,
             Config.SessionToken);

Minio/DataModel/Args/BucketArgs.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * MinIO .NET Library for Amazon S3 Compatible Cloud Storage, (C) 2020, 2021 MinIO, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -29,6 +29,9 @@ public abstract class BucketArgs<T> : RequestArgs
 
     internal IDictionary<string, string> Headers { get; set; } = new Dictionary<string, string>(StringComparer.Ordinal);
 
+    internal IDictionary<string, string> Parameters { get; set; } =
+        new Dictionary<string, string>(StringComparer.Ordinal);
+
     public T WithBucket(string bucket)
     {
         BucketName = bucket;
@@ -48,6 +51,19 @@ public virtual T WithHeaders(IDictionary<string, string> headers)
         return (T)this;
     }
 
+    public virtual T WithParameters(IDictionary<string, string> parameters)
+    {
+        if (parameters is null || parameters.Count <= 0) return (T)this;
+        Parameters ??= new Dictionary<string, string>(StringComparer.Ordinal);
+        foreach (var key in parameters.Keys)
+        {
+            _ = Parameters.Remove(key);
+            Parameters[key] = parameters[key];
+        }
+
+        return (T)this;
+    }
+
     internal virtual void Validate()
     {
         Utils.ValidateBucketName(BucketName);

Minio/RequestExtensions.cs

@@ -191,6 +191,7 @@ await minioClient.CreateRequest(args.RequestMethod,
                 args.BucketName,
                 args.ObjectName,
                 args.Headers,
+                args.Parameters,
                 args.RequestBody).ConfigureAwait(false);
         return args.BuildRequest(requestMessageBuilder);
     }
@@ -214,6 +215,7 @@ private static string GetContentType(IDictionary<string, string> headerMap)
     /// <param name="bucketName">Bucket Name</param>
     /// <param name="objectName">Object Name</param>
     /// <param name="headerMap">headerMap</param>
+    /// <param name="parameterMap">parameterMap</param>
     /// <param name="body">request body</param>
     /// <param name="resourcePath">query string</param>
     /// <param name="isBucketCreationRequest">boolean to define bucket creation</param>
@@ -224,6 +226,7 @@ internal static async Task<HttpRequestMessageBuilder> CreateRequest(this IMinioC
         string bucketName = null,
         string objectName = null,
         IDictionary<string, string> headerMap = null,
+        IDictionary<string, string> parameterMap = null,
         ReadOnlyMemory<byte> body = default,
         string resourcePath = null,
         bool isBucketCreationRequest = false)
@@ -322,6 +325,10 @@ internal static async Task<HttpRequestMessageBuilder> CreateRequest(this IMinioC
             foreach (var entry in headerMap) messageBuilder.AddOrUpdateHeaderParameter(entry.Key, entry.Value);
         }
 
+        if (parameterMap is not null)
+            foreach (var entry in parameterMap)
+                messageBuilder.AddQueryParameter(entry.Key, entry.Value);
+
         return messageBuilder;
     }
 

Minio/V4Authenticator.cs

@@ -279,8 +279,18 @@ internal string PresignURL(
 
         var headersToSign = GetHeadersToSign(requestBuilder);
         var signedHeaders = GetSignedHeaders(headersToSign);
+        var parametersToCanonicalize = GetParametersToCanonicalize(requestBuilder);
 
-        var requestQuery = GetCanonicalQueryString(requestBuilder.RequestUri, reqDate, region, expires, signedHeaders);
+        var credentials = string.Format(CultureInfo.InvariantCulture, "{0}/{1}/{2}/{3}/{4}", accessKey,
+            Utils.FormatDate(signingDate), region, GetService(false), Terminator);
+
+        parametersToCanonicalize.Add(Constants.XAmzAlgorithm, AWS4AlgorithmTag);
+        parametersToCanonicalize.Add(Constants.XAmzCredential, credentials);
+        parametersToCanonicalize.Add(Constants.XAmzDate, Utils.FormatDateTime(signingDate));
+        parametersToCanonicalize.Add(Constants.XAmzExpires, Convert.ToString(expires));
+        parametersToCanonicalize.Add(Constants.XAmzSignedHeaders, signedHeaders);
+
+        var requestQuery = GetCanonicalQueryString(requestBuilder.RequestUri, parametersToCanonicalize);
         var canonicalRequest =
             GetPresignCanonicalRequest(requestBuilder.Method, requestUri, headersToSign, requestQuery);
 
@@ -293,6 +303,15 @@ internal string PresignURL(
         return ComposePresignedPutUrl(requestUri, requestQuery, signature);
     }
 
+    private IDictionary<string, string> GetParametersToCanonicalize(HttpRequestMessageBuilder request)
+    {
+        var parameters = new SortedDictionary<string, string>(StringComparer.Ordinal);
+        foreach (var param in request.QueryParameters)
+            if (param.Value is not null)
+                parameters.Add(param.Key, param.Value);
+        return parameters;
+    }
+
     private string ComposePresignedPutUrl(
         Uri presignUri,
         string queryParams,
@@ -310,34 +329,16 @@ private string ComposePresignedPutUrl(
     /// <summary>
     ///     Generates canonical query string.
     /// </summary>
-    /// <param name="requestUri"></param>
-    /// <param name="reqDate"></param>
-    /// <param name="region"></param>
-    /// <param name="expires"></param>
-    /// <param name="signedHeaders"></param>
-    /// <param name="isSts"></param>
+    /// <param name="requestUri">Request uri</param>
+    /// <param name="queryParams">Query parameters to be included in signed url</param>
     /// <returns>Canonical query string</returns>
     internal string GetCanonicalQueryString(
         Uri requestUri,
-        DateTime? reqDate,
-        string region,
-        int expires,
-        string signedHeaders,
-        bool isSts = false)
+        IDictionary<string, string> queryParams
+    )
     {
         var canonicalQueryString = new StringBuilder(requestUri.Query);
         if (canonicalQueryString.Length != 0) _ = canonicalQueryString.Append("&");
-        var signingDate = reqDate ?? DateTime.UtcNow;
-        var creds = string.Format(CultureInfo.InvariantCulture, "{0}/{1}/{2}/{3}/{4}", accessKey,
-            Utils.FormatDate(signingDate), region, GetService(isSts), Terminator);
-        var queryParams = new SortedDictionary<string, string>(StringComparer.Ordinal)
-        {
-            { Constants.XAmzAlgorithm, AWS4AlgorithmTag },
-            { Constants.XAmzCredential, creds },
-            { Constants.XAmzDate, Utils.FormatDateTime(signingDate) },
-            { Constants.XAmzExpires, Convert.ToString(expires) },
-            { Constants.XAmzSignedHeaders, signedHeaders }
-        };
         foreach (var query in queryParams)
         {
             if (canonicalQueryString.Length > 0)