Fix URI encoding when path segment contains slashes ("/") and update Chime global endpoint

Author: wps132230

aws-cpp-sdk-chime/source/ChimeClient.cpp

@@ -22,7 +22,7 @@ namespace ChimeEndpoint
   {
     AWS_UNREFERENCED_PARAM(regionName);
     AWS_UNREFERENCED_PARAM(useDualStack);
-    return "service.chime.aws.amazon.com";
+    return "chime.us-east-1.amazonaws.com";
   }
 
 } // namespace ChimeEndpoint

aws-cpp-sdk-chime/source/ChimeEndpoint.cpp

@@ -46,9 +46,9 @@ TEST(URITest, TestSetPath)
     uri.SetPath(path);
     EXPECT_EQ(path, uri.GetPath());
 
-    path = "path/to/resource/";
+    path = "path/to/resource";
     uri.SetPath(path);
-    EXPECT_EQ("/path/to/resource/", uri.GetPath());
+    EXPECT_EQ("/path/to/resource", uri.GetPath());
 
     path = "//path/to//resource";
     uri.SetPath(path);
@@ -62,6 +62,52 @@ TEST(URITest, TestSetPath)
     EXPECT_EQ(path, uri.GetPath());
 }
 
+TEST(URITest, TestAddPathSegments)
+{
+    URI uri;
+
+    uri.AddPathSegment("//");
+    EXPECT_STREQ("/", uri.GetPath().c_str());
+    EXPECT_STREQ("/", uri.GetURLEncodedPath().c_str());
+
+    uri.SetPath("");
+    uri.AddPathSegment("/path/");
+    EXPECT_STREQ("/path", uri.GetPath().c_str());
+    EXPECT_STREQ("/path", uri.GetURLEncodedPath().c_str());
+
+    uri.SetPath("");
+    uri.AddPathSegment("/path/");
+    uri.AddPathSegment("to");
+    uri.AddPathSegment("/some");
+    uri.AddPathSegment("resource/");
+    EXPECT_STREQ("/path/to/some/resource", uri.GetPath().c_str());
+    EXPECT_STREQ("/path/to/some/resource", uri.GetURLEncodedPath().c_str());
+
+    uri.SetPath("");
+    uri.AddPathSegment("/int");
+    uri.AddPathSegment(10);
+    uri.AddPathSegment("float");
+    uri.AddPathSegment(12.34);
+    EXPECT_STREQ("/int/10/float/12.34", uri.GetPath().c_str());
+    EXPECT_STREQ("/int/10/float/12.34", uri.GetURLEncodedPath().c_str());
+
+    uri.SetPath("");
+    // There is no way to tell the differences between slashes in path segment and slashed as delimiters before encoding.
+    uri.AddPathSegment("/path/segment/");
+    EXPECT_STREQ("/path/segment", uri.GetPath().c_str());
+    EXPECT_STREQ("/path%2Fsegment", uri.GetURLEncodedPath().c_str());
+
+    uri.SetPath("");
+    uri.AddPathSegments("//");
+    EXPECT_STREQ("/", uri.GetPath().c_str());
+    EXPECT_STREQ("/", uri.GetURLEncodedPath().c_str());
+
+    uri.SetPath("");
+    uri.AddPathSegments("//path/to//resource/");
+    EXPECT_STREQ("/path/to/resource", uri.GetPath().c_str());
+    EXPECT_STREQ("/path/to/resource", uri.GetURLEncodedPath().c_str());
+}
+
 TEST(URITest, TestAddQueryStringParameters)
 {
     URI uri;
@@ -173,8 +219,8 @@ TEST(URITest, TestParse)
     EXPECT_EQ(Scheme::HTTP, uriThatBrokeTheOtherDay.GetScheme());
     EXPECT_EQ("sqs.us-east-1.amazonaws.com", uriThatBrokeTheOtherDay.GetAuthority());
     EXPECT_EQ(80, uriThatBrokeTheOtherDay.GetPort());
-    EXPECT_EQ("/686094048/testQueueName/", uriThatBrokeTheOtherDay.GetPath());
-    EXPECT_EQ("http://sqs.us-east-1.amazonaws.com/686094048/testQueueName/", uriThatBrokeTheOtherDay.GetURIString());
+    EXPECT_EQ("/686094048/testQueueName", uriThatBrokeTheOtherDay.GetPath());
+    EXPECT_EQ("http://sqs.us-east-1.amazonaws.com/686094048/testQueueName", uriThatBrokeTheOtherDay.GetURIString());
 }
 
 TEST(URITest, TestParseWithColon)
@@ -232,7 +278,7 @@ TEST(URITest, TestGetURLEncodedPath)
 TEST(URITest, TestGetRFC3986URLEncodedPath)
 {
     URI uri = "https://test.com/path/1234/";
-    EXPECT_STREQ("/path/1234/", URI::URLEncodePathRFC3986(uri.GetPath()).c_str());
+    EXPECT_STREQ("/path/1234", URI::URLEncodePathRFC3986(uri.GetPath()).c_str());
 
     uri = "https://test.com/path/$omething";
     EXPECT_STREQ("/path/$omething", URI::URLEncodePathRFC3986(uri.GetPath()).c_str());

aws-cpp-sdk-core-tests/http/URITest.cpp

@@ -9,7 +9,7 @@
 
 #include <aws/core/http/Scheme.h>
 #include <aws/core/utils/memory/stl/AWSMap.h>
-#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/StringUtils.h>
 
 #include <stdint.h>
 
@@ -89,18 +89,51 @@ namespace Aws
             * Gets the path portion of the uri e.g. the portion after the first slash after the authority and prior to the
             * query string. This is not url encoded.
             */
-            inline const Aws::String& GetPath() const { return m_path; }
+            Aws::String GetPath() const;
 
             /**
             * Gets the path portion of the uri, url encodes it and returns it
             */
-            inline Aws::String GetURLEncodedPath() const { return URLEncodePath(m_path); }
+            Aws::String GetURLEncodedPath() const;
+
+            /**
+             * Gets the path portion of the uri, url encodes it according to RFC3986 and returns it.
+             */
+            Aws::String GetURLEncodedPathRFC3986() const;
 
             /**
             * Sets the path portion of the uri. URL encodes it if needed
             */
             void SetPath(const Aws::String& value);
 
+            /**
+             * Add a path segment to the uri.
+             */
+            template<typename T>
+            inline void AddPathSegment(T pathSegment)
+            {
+                Aws::StringStream ss;
+                ss << pathSegment;
+                Aws::String segment = ss.str();
+                segment.erase(0, segment.find_first_not_of('/'));
+                segment.erase(segment.find_last_not_of('/') + 1);
+                m_pathSegments.push_back(segment);
+            }
+
+            /**
+             * Add path segments to the uri.
+             */
+            template<typename T>
+            inline void AddPathSegments(T pathSegments)
+            {
+                Aws::StringStream ss;
+                ss << pathSegments;
+                for (const auto& segment : Aws::Utils::StringUtils::Split(ss.str(), '/'))
+                {
+                    m_pathSegments.push_back(segment);
+                }
+            }
+
             /**
             * Gets the raw query string including the ?
             */
@@ -162,7 +195,7 @@ namespace Aws
             Scheme m_scheme;
             Aws::String m_authority;
             uint16_t m_port;
-            Aws::String m_path;
+            Aws::Vector<Aws::String> m_pathSegments;
             Aws::String m_queryString;
         };
 

aws-cpp-sdk-core/include/aws/core/http/URI.h

@@ -82,16 +82,14 @@ static Aws::String CanonicalizeRequestSigningString(HttpRequest& request, bool u
     if(urlEscapePath)
     {
         // RFC3986 is how we encode the URL before sending it on the wire.
-        auto rfc3986EncodedPath = URI::URLEncodePathRFC3986(uriCpy.GetPath());
-        uriCpy.SetPath(rfc3986EncodedPath);
+        uriCpy.SetPath(uriCpy.GetURLEncodedPathRFC3986());
         // However, SignatureV4 uses this URL encoding scheme
         signingStringStream << NEWLINE << uriCpy.GetURLEncodedPath() << NEWLINE;
     }
     else
     {
         // For the services that DO decode the URL first; we don't need to double encode it.
-        uriCpy.SetPath(uriCpy.GetURLEncodedPath());
-        signingStringStream << NEWLINE << uriCpy.GetPath() << NEWLINE;
+        signingStringStream << NEWLINE << uriCpy.GetURLEncodedPath() << NEWLINE;
     }
 
     if (request.GetQueryString().find('=') != std::string::npos)

aws-cpp-sdk-core/source/auth/AWSAuthSigner.cpp

@@ -5,8 +5,6 @@
 
 #include <aws/core/http/URI.h>
 
-#include <aws/core/utils/StringUtils.h>
-#include <aws/core/utils/memory/stl/AWSStringStream.h>
 #include <aws/core/utils/memory/stl/AWSSet.h>
 
 #include <cstdlib>
@@ -176,23 +174,88 @@ Aws::String URI::URLEncodePath(const Aws::String& path)
     }
 }
 
-void URI::SetPath(const Aws::String& value)
+Aws::String URI::GetPath() const
 {
-    const Aws::Vector<Aws::String> pathParts = StringUtils::Split(value, '/');
-    Aws::String path;
-    path.reserve(value.length() + 1/* in case we have to append slash before the path. */);
+    Aws::String path = "";
 
-    for (const auto& segment : pathParts)
+    for (auto const& segment : m_pathSegments)
     {
         path.push_back('/');
         path.append(segment);
     }
 
-    if (value.back() == '/')
+    if (m_pathSegments.empty())
     {
         path.push_back('/');
     }
-    m_path = std::move(path);
+
+    return path;
+}
+
+Aws::String URI::GetURLEncodedPath() const
+{
+    Aws::StringStream ss;
+
+    for (auto const& segment : m_pathSegments)
+    {
+        ss << '/' << StringUtils::URLEncode(segment.c_str());
+    }
+
+    if (m_pathSegments.empty())
+    {
+        ss << '/';
+    }
+
+    return ss.str();
+}
+
+Aws::String URI::GetURLEncodedPathRFC3986() const
+{
+    Aws::StringStream ss;
+    ss << std::hex << std::uppercase;
+
+    // escape characters appearing in a URL path according to RFC 3986
+    for (const auto& segment : m_pathSegments)
+    {
+        ss << '/';
+        for(unsigned char c : segment) // alnum results in UB if the value of c is not unsigned char & is not EOF
+        {
+            // §2.3 unreserved characters
+            if (StringUtils::IsAlnum(c))
+            {
+                ss << c;
+                continue;
+            }
+            switch(c)
+            {
+                // §2.3 unreserved characters
+                case '-': case '_': case '.': case '~':
+                // The path section of the URL allow reserved characters to appear unescaped
+                // RFC 3986 §2.2 Reserved characters
+                // NOTE: this implementation does not accurately implement the RFC on purpose to accommodate for
+                // discrepancies in the implementations of URL encoding between AWS services for legacy reasons.
+                case '$': case '&': case ',':
+                case ':': case '=': case '@':
+                    ss << c;
+                    break;
+                default:
+                    ss << '%' << std::setfill('0') << std::setw(2) << (int)((unsigned char)c) << std::setw(0);
+            }
+        }
+    }
+
+    if (m_pathSegments.empty())
+    {
+        ss << '/';
+    }
+
+    return ss.str();
+}
+
+void URI::SetPath(const Aws::String& value)
+{
+    const Aws::Vector<Aws::String> pathParts = StringUtils::Split(value, '/');
+    m_pathSegments = std::move(pathParts);
 }
 
 //ugh, this isn't even part of the canonicalization spec. It is part of how our services have implemented their signers though....
@@ -347,9 +410,9 @@ Aws::String URI::GetURIString(bool includeQueryString) const
         ss << ":" << m_port;
     }
 
-    if(m_path != "/")
+    if (!m_pathSegments.empty())
     {
-        ss << URLEncodePathRFC3986(m_path);
+        ss << GetURLEncodedPathRFC3986();
     }
 
     if(includeQueryString)
@@ -506,5 +569,5 @@ Aws::String URI::GetFormParameters() const
 
 bool URI::CompareURIParts(const URI& other) const
 {
-    return m_scheme == other.m_scheme && m_authority == other.m_authority && m_path == other.m_path && m_queryString == other.m_queryString;
+    return m_scheme == other.m_scheme && m_authority == other.m_authority && GetPath() == other.GetPath() && m_queryString == other.m_queryString;
 }

aws-cpp-sdk-core/source/http/URI.cpp

@@ -260,7 +260,7 @@ std::shared_ptr<HttpResponse> WinSyncHttpClient::MakeRequest(const std::shared_p
 {
 	//we URL encode right before going over the wire to avoid double encoding problems with the signer.
 	URI& uriRef = request->GetUri();
-	uriRef.SetPath(URI::URLEncodePathRFC3986(uriRef.GetPath()));
+	uriRef.SetPath(uriRef.GetURLEncodedPathRFC3986());
 
     AWS_LOGSTREAM_TRACE(GetLogTag(), "Making " << HttpMethodMapper::GetNameForHttpMethod(request->GetMethod()) <<
 			" request to uri " << uriRef.GetURIString(true));

aws-cpp-sdk-core/source/http/windows/WinSyncHttpClient.cpp

@@ -15,20 +15,18 @@
 
 @Data
 public class Http {
-    private static final Pattern URI_PARAM_PATTERN = Pattern.compile(".*\\{[\\w\\d-]+\\}");
+    private static final Pattern URI_PARAM_PATTERN = Pattern.compile(".*\\{[\\w\\d-]+\\+?\\}");
 
     private String method;
     private String requestUri;
     private String responseCode;
 
     public List<String> getRequestUriParts() {
-        String sanitizedUri = requestUri.replace("+", "");
-        return Arrays.asList(sanitizedUri.split("\\{[\\w\\d-]+\\}"));
+        return Arrays.asList(requestUri.split("\\{[\\w\\d-]+\\+?\\}"));
     }
 
     public List<String> getRequestParameters() {
-        String sanitizedUri = requestUri.replace("+", "");
-        String[] parts = sanitizedUri.split("/|\\?|&");
+        String[] parts = requestUri.split("/|\\?|&");
         List<String> paramList = new LinkedList<>();
 
         for (String part : parts) {

code-generation/generator/src/main/java/com/amazonaws/util/awsclientgenerator/domainmodels/codegeneration/Http.java

@@ -383,7 +383,7 @@ protected Map<String, String> computeEndpointMappingForService(ServiceModel serv
             serviceModel.getMetadata().setGlobalEndpoint("ce.us-east-1.amazonaws.com");
 
         } else if (serviceModel.getServiceName().equals("chime")) {
-            serviceModel.getMetadata().setGlobalEndpoint("service.chime.aws.amazon.com");
+            serviceModel.getMetadata().setGlobalEndpoint("chime.us-east-1.amazonaws.com");
 
         } else if (serviceModel.getServiceName().equals("iam")) {
             endpoints.put("cn-north-1", "iam.cn-north-1.amazonaws.com.cn");