Burl: SOCKS5 proxy support

Author: ashtum

example/client/burl/main.cpp

@@ -720,6 +720,174 @@ class message
     }
 };
 
+asio::awaitable<void>
+connect_socks5_proxy(
+    asio::ip::tcp::socket& stream,
+    urls::url_view url,
+    urls::url_view proxy)
+{
+    auto executor = co_await asio::this_coro::executor;
+    auto resolver = asio::ip::tcp::resolver{ executor };
+    auto rresults = co_await resolver.async_resolve(
+        proxy.host(), effective_port(proxy));
+
+    // Connect to the proxy server
+    co_await asio::async_connect(stream, rresults);
+
+    // Greeting request
+    if(proxy.has_userinfo())
+    {
+        std::uint8_t greeting_req[4] = { 0x05, 0x02, 0x00, 0x02 };
+        co_await asio::async_write(stream, asio::buffer(greeting_req));
+    }
+    else
+    {
+        std::uint8_t greeting_req[3] = { 0x05, 0x01, 0x00 };
+        co_await asio::async_write(stream, asio::buffer(greeting_req));
+    }
+
+    // Greeting response
+    std::uint8_t greeting_resp[2];
+    co_await asio::async_read(stream, asio::buffer(greeting_resp));
+
+    if(greeting_resp[0] != 0x05)
+        throw std::runtime_error{ "SOCKS5 invalid version" };
+
+    switch(greeting_resp[1])
+    {
+    case 0x00: // No Authentication
+        break;
+    case 0x02: // Username/password
+    {
+        // Authentication request
+        auto auth_req = std::string{ 0x01 };
+
+        auto user = proxy.encoded_user();
+        auth_req.push_back(static_cast<std::uint8_t>(user.decoded_size()));
+        user.decode({}, urls::string_token::append_to(auth_req));
+
+        auto pass = proxy.encoded_password();
+        auth_req.push_back(static_cast<std::uint8_t>(pass.decoded_size()));
+        pass.decode({}, urls::string_token::append_to(auth_req));
+
+        co_await asio::async_write(stream, asio::buffer(auth_req));
+
+        // Authentication response
+        std::uint8_t greeting_resp[2];
+        co_await asio::async_read(stream, asio::buffer(greeting_resp));
+
+        if(greeting_resp[1] != 0x00)
+            throw std::runtime_error{
+                "SOCKS5 authentication failed" };
+        break;
+    }
+    default:
+        throw std::runtime_error{
+            "SOCKS5 no acceptable authentication method"
+        };
+    }
+
+    // Connection request
+    auto conn_req = std::string{ 0x05, 0x01, 0x00, 0x03 };
+    auto host     = url.encoded_host();
+    conn_req.push_back(static_cast<std::uint8_t>(host.decoded_size()));
+    host.decode({}, urls::string_token::append_to(conn_req));
+
+    std::uint16_t port = std::stoi(effective_port(url));
+    conn_req.push_back(static_cast<std::uint8_t>((port >> 8) & 0xFF));
+    conn_req.push_back(static_cast<std::uint8_t>(port & 0xFF));
+
+    co_await asio::async_write(stream, asio::buffer(conn_req));
+
+    // Connection response
+    std::uint8_t conn_resp_head[5];
+    co_await asio::async_read(stream, asio::buffer(conn_resp_head));
+
+    if(conn_resp_head[1] != 0x00)
+        throw std::runtime_error{
+            "SOCKS5 connection request failed" };
+
+    std::string conn_resp_tail;
+    conn_resp_tail.resize(
+        [&]()
+        {
+            // subtract 1 because we have pre-read one byte
+            switch(conn_resp_head[3])
+            {
+            case 0x01:
+                return 4 + 2 - 1; // ipv4 + port
+            case 0x03:
+                return conn_resp_head[4] + 2 - 1; // domain name + port
+            case 0x04:
+                return 16 + 2 - 1; // ipv6 + port
+            default:
+                throw std::runtime_error{
+                    "SOCKS5 invalid address type" };
+            }
+        }()); 
+    co_await asio::async_read(stream, asio::buffer(conn_resp_tail));
+}
+
+asio::awaitable<void>
+connect_http_proxy(
+    const po::variables_map& vm,
+    http_proto::context& http_proto_ctx,
+    asio::ip::tcp::socket& stream,
+    urls::url_view url,
+    urls::url_view proxy)
+{
+    auto executor = co_await asio::this_coro::executor;
+    auto resolver = asio::ip::tcp::resolver{ executor };
+    auto rresults = co_await resolver.async_resolve(
+        proxy.host(), effective_port(proxy));
+
+    // Connect to the proxy server
+    co_await asio::async_connect(stream, rresults);
+
+    using http_proto::field;
+    auto request   = http_proto::request{};
+    auto host_port = [&]()
+    {
+        auto rs = url.encoded_host().decode();
+        rs.push_back(':');
+        rs.append(effective_port(url));
+        return rs;
+    }();
+
+    request.set_method(http_proto::method::connect);
+    request.set_target(host_port);
+    request.set(field::host, host_port);
+    request.set(field::proxy_connection, "keep-alive");
+
+    if(vm.count("user-agent"))
+    {
+        request.set(
+            field::user_agent,
+            vm.at("user-agent").as<std::string>());
+    }
+    else
+    {
+        request.set(field::user_agent, "Boost.Http.Io");
+    }
+
+    // TODO
+    // request.set(field::proxy_authorization, "");
+
+    auto serializer = http_proto::serializer{ http_proto_ctx };
+    auto parser     = http_proto::response_parser{ http_proto_ctx };
+
+    serializer.start(request);
+    co_await http_io::async_write(stream, serializer);
+
+    parser.reset();
+    parser.start();
+    co_await http_io::async_read_header(stream, parser);
+
+    if(parser.get().status() != http_proto::status::ok)
+        throw std::runtime_error{
+            "Proxy server rejected the connection" };
+}
+
 asio::awaitable<any_stream>
 connect(
     const po::variables_map& vm,
@@ -728,7 +896,6 @@ connect(
     urls::url_view url)
 {
     auto executor = co_await asio::this_coro::executor;
-    auto resolver = asio::ip::tcp::resolver{ executor };
     auto stream   = asio::ip::tcp::socket{ executor };
 
     if(vm.count("proxy"))
@@ -738,63 +905,31 @@ connect(
         if(proxy_url.has_error())
             throw system_error{ proxy_url.error(), "Failed to parse proxy" };
 
-        if(proxy_url->scheme() != "http")
-            throw std::runtime_error{ "only HTTP proxies are supported" };
-
-        // Connect to the HTTP proxy server
-        auto rr = co_await resolver.async_resolve(
-            proxy_url->host(), effective_port(proxy_url.value()));
-        co_await asio::async_connect(stream, rr);
-
+        if(proxy_url->scheme() == "http")
         {
-            using http_proto::field;
-            auto request = http_proto::request{};
-            auto host    = std::string{ url.encoded_host() };
-
-            host.push_back(':');
-            host.append(effective_port(url));
-
-            request.set_method(http_proto::method::connect);
-            request.set_target(host);
-            request.set(field::host, host);
-            request.set(field::proxy_connection, "keep-alive");
-
-            if(vm.count("user-agent"))
-            {
-                request.set(
-                    field::user_agent,
-                    vm.at("user-agent").as<std::string>());
-            }
-            else
-            {
-                request.set(field::user_agent, "Boost.Http.Io");
-            }
-
-            // TODO
-            // request.set(field::proxy_authorization, "");
-
-            auto serializer = http_proto::serializer{ http_proto_ctx };
-            serializer.start(request);
-            co_await http_io::async_write(stream, serializer);
+            co_await connect_http_proxy(
+                vm, http_proto_ctx, stream, url, proxy_url.value());
         }
-
+        else if(proxy_url->scheme() == "socks5")
         {
-            auto parser = http_proto::response_parser{ http_proto_ctx };
-            parser.reset();
-            parser.start();
-            co_await http_io::async_read_header(stream, parser);
-            if(parser.get().status() != http_proto::status::ok)
-                throw std::runtime_error{
-                    "Proxy server rejected the connection" };
+            co_await connect_socks5_proxy(
+                stream, url, proxy_url.value());
+        }
+        else
+        {
+            throw std::runtime_error{
+                "only HTTP and SOCKS5 proxies are supported" };
         }
     }
     else // no proxy
     {
-        auto rr = co_await resolver.async_resolve(
+        auto resolver = asio::ip::tcp::resolver{ executor };
+        auto rresults = co_await resolver.async_resolve(
             url.host(), effective_port(url));
-        co_await asio::async_connect(stream, rr);
+        co_await asio::async_connect(stream, rresults);
     }
 
+    // TLS handshake
     if(url.scheme() == "https")
     {
         auto ssl_stream = ssl::stream<asio::ip::tcp::socket>{