cpp（boost :: Asio）で私のプロキシのブラウザからアドレスを取得しています

Question

私は、ブラウザで使用するためにTCPプロキシのサンプルコードを適応しようとしています。

は、ここで私が使用して完全な代理である：実際に

#include <cstdlib> 
#include <cstddef> 
#include <iostream> 
#include <string> 

#include <boost/shared_ptr.hpp> 
#include <boost/enable_shared_from_this.hpp> 
#include <boost/bind.hpp> 
#include <boost/asio.hpp> 
#include <boost/thread/mutex.hpp> 


namespace tcp_proxy 
{ 
    namespace ip = boost::asio::ip; 

    class bridge : public boost::enable_shared_from_this<bridge> 
    { 
    public: 

     typedef ip::tcp::socket socket_type; 
     typedef boost::shared_ptr<bridge> ptr_type; 

     bridge(boost::asio::io_service& ios) 
     : downstream_socket_(ios), 
     upstream_socket_(ios) 
     {} 

     socket_type& downstream_socket() 
     { 
     return downstream_socket_; 
     } 

     socket_type& upstream_socket() 
     { 
     return upstream_socket_; 
     } 

     void start(const std::string& upstream_host, unsigned short upstream_port) 
     { 
     upstream_socket_.async_connect(
       ip::tcp::endpoint(
        boost::asio::ip::address::from_string(upstream_host), 
        upstream_port), 
       boost::bind(&bridge::handle_upstream_connect, 
        shared_from_this(), 
        boost::asio::placeholders::error)); 
     } 

     void handle_upstream_connect(const boost::system::error_code& error) 
     { 
     if (!error) 
     { 
      upstream_socket_.async_read_some(
       boost::asio::buffer(upstream_data_,max_data_length), 
       boost::bind(&bridge::handle_upstream_read, 
         shared_from_this(), 
         boost::asio::placeholders::error, 
         boost::asio::placeholders::bytes_transferred)); 

      downstream_socket_.async_read_some(
       boost::asio::buffer(downstream_data_,max_data_length), 
       boost::bind(&bridge::handle_downstream_read, 
         shared_from_this(), 
         boost::asio::placeholders::error, 
         boost::asio::placeholders::bytes_transferred)); 
     } 
     else 
      close(); 
     } 

    private: 

     void handle_downstream_write(const boost::system::error_code& error) 
     { 
     if (!error) 
     { 
      upstream_socket_.async_read_some(
       boost::asio::buffer(upstream_data_,max_data_length), 
       boost::bind(&bridge::handle_upstream_read, 
         shared_from_this(), 
         boost::asio::placeholders::error, 
         boost::asio::placeholders::bytes_transferred)); 
     } 
     else 
      close(); 
     } 

     void handle_downstream_read(const boost::system::error_code& error, 
            const size_t& bytes_transferred) 
     { 
     if (!error) 
     { 
      async_write(upstream_socket_, 
        boost::asio::buffer(downstream_data_,bytes_transferred), 
        boost::bind(&bridge::handle_upstream_write, 
         shared_from_this(), 
         boost::asio::placeholders::error)); 
     } 
     else 
      close(); 
     } 

     void handle_upstream_write(const boost::system::error_code& error) 
     { 
     if (!error) 
     { 
      downstream_socket_.async_read_some(
       boost::asio::buffer(downstream_data_,max_data_length), 
       boost::bind(&bridge::handle_downstream_read, 
         shared_from_this(), 
         boost::asio::placeholders::error, 
         boost::asio::placeholders::bytes_transferred)); 
     } 
     else 
      close(); 
     } 

     void handle_upstream_read(const boost::system::error_code& error, 
           const size_t& bytes_transferred) 
     { 
     if (!error) 
     { 
      async_write(downstream_socket_, 
       boost::asio::buffer(upstream_data_,bytes_transferred), 
       boost::bind(&bridge::handle_downstream_write, 
         shared_from_this(), 
         boost::asio::placeholders::error)); 
     } 
     else 
      close(); 
     } 

     void close() 
     { 
     boost::mutex::scoped_lock lock(mutex_); 

     if (downstream_socket_.is_open()) 
     { 
      downstream_socket_.close(); 
     } 

     if (upstream_socket_.is_open()) 
     { 
      upstream_socket_.close(); 
     } 
     } 

     socket_type downstream_socket_; 
     socket_type upstream_socket_; 

     enum { max_data_length = 8192 }; //8KB 
     unsigned char downstream_data_[max_data_length]; 
     unsigned char upstream_data_[max_data_length]; 

     boost::mutex mutex_; 

    public: 

     class acceptor 
     { 
     public: 

     acceptor(boost::asio::io_service& io_service, 
        const std::string& local_host, unsigned short local_port, 
        const std::string& upstream_host, unsigned short upstream_port) 
     : io_service_(io_service), 
      localhost_address(boost::asio::ip::address_v4::from_string(local_host)), 
      acceptor_(io_service_,ip::tcp::endpoint(localhost_address,local_port)), 
      upstream_port_(upstream_port), 
      upstream_host_(upstream_host) 
     {} 

     bool accept_connections() 
     { 
      try 
      { 
       session_ = boost::shared_ptr<bridge>(new bridge(io_service_)); 

       acceptor_.async_accept(session_->downstream_socket(), 
        boost::bind(&acceptor::handle_accept, 
         this, 
         boost::asio::placeholders::error)); 
      } 
      catch(std::exception& e) 
      { 
       std::cerr << "acceptor exception: " << e.what() << std::endl; 
       return false; 
      } 

      return true; 
     } 

     private: 

     void handle_accept(const boost::system::error_code& error) 
     { 
      if (!error) 
      { 
       session_->start(upstream_host_,upstream_port_); 

       if (!accept_connections()) 
       { 
        std::cerr << "Failure during call to accept." << std::endl; 
       } 
      } 
      else 
      { 
       std::cerr << "Error: " << error.message() << std::endl; 
      } 
     } 

     boost::asio::io_service& io_service_; 
     ip::address_v4 localhost_address; 
     ip::tcp::acceptor acceptor_; 
     ptr_type session_; 
     unsigned short upstream_port_; 
     std::string upstream_host_; 
     }; 

    }; 
} 

int main(int argc, char* argv[]) 
{ 
    if (argc != 5) 
    { 
     std::cerr << "usage: tcpproxy_server <local host ip> <local port> <forward host ip> <forward port>" << std::endl; 
     return 1; 
    } 

    const unsigned short local_port = static_cast<unsigned short>(::atoi(argv[2])); 
    const unsigned short forward_port = static_cast<unsigned short>(::atoi(argv[4])); 
    const std::string local_host  = argv[1]; 
    const std::string forward_host = argv[3]; 

    boost::asio::io_service ios; 

    try 
    { 
     tcp_proxy::bridge::acceptor acceptor(ios, 
              local_host, local_port, 
              forward_host, forward_port); 

     acceptor.accept_connections(); 

     ios.run(); 
    } 
    catch(std::exception& e) 
    { 
     std::cerr << "Error: " << e.what() << std::endl; 
     return 1; 
    } 

    return 0; 
} 

、ローカルホストとローカルポート、およびポートフォワードと前方ホストを引数として、このサンプルコードが必要。私の研究から、私は、自動的にブラウザに要求されたホストを得るために、このコードを編集したい

...

iはremote_endpoint（）プロパティを使用する必要があります。

#include <cstdlib> 
#include <cstddef> 
#include <iostream> 
#include <string> 

#include <boost/shared_ptr.hpp> 
#include <boost/enable_shared_from_this.hpp> 
#include <boost/bind.hpp> 
#include <boost/asio.hpp> 
#include <boost/thread/mutex.hpp> 


namespace tcp_proxy 
{ 
    namespace ip = boost::asio::ip; 

    class bridge : public boost::enable_shared_from_this<bridge> 
    { 
    public: 

     typedef ip::tcp::socket socket_type; 
     typedef boost::shared_ptr<bridge> ptr_type; 

     bridge(boost::asio::io_service& ios) 
      : downstream_socket_(ios), 
      upstream_socket_(ios) 
     {} 

     socket_type& downstream_socket() 
     { 
      return downstream_socket_; 
     } 

     socket_type& upstream_socket() 
     { 
      return upstream_socket_; 
     } 

     void start(const std::string& upstream_host, unsigned short upstream_port) 
     { 
      upstream_socket_.async_connect(
       ip::tcp::endpoint(
        boost::asio::ip::address::from_string(upstream_host), 
        upstream_port), 
       boost::bind(&bridge::handle_upstream_connect, 
        shared_from_this(), 
        boost::asio::placeholders::error)); 
     } 

     void handle_upstream_connect(const boost::system::error_code& error) 
     { 
      if (!error) 
      { 
       upstream_socket_.async_read_some(
        boost::asio::buffer(upstream_data_, max_data_length), 
        boost::bind(&bridge::handle_upstream_read, 
         shared_from_this(), 
         boost::asio::placeholders::error, 
         boost::asio::placeholders::bytes_transferred)); 

       downstream_socket_.async_read_some(
        boost::asio::buffer(downstream_data_, max_data_length), 
        boost::bind(&bridge::handle_downstream_read, 
         shared_from_this(), 
         boost::asio::placeholders::error, 
         boost::asio::placeholders::bytes_transferred)); 
      } 
      else 
       close(); 
     } 

    private: 

     void handle_downstream_write(const boost::system::error_code& error) 
     { 
      if (!error) 
      { 
       upstream_socket_.async_read_some(
        boost::asio::buffer(upstream_data_, max_data_length), 
        boost::bind(&bridge::handle_upstream_read, 
         shared_from_this(), 
         boost::asio::placeholders::error, 
         boost::asio::placeholders::bytes_transferred)); 
      } 
      else 
       close(); 
     } 

     void handle_downstream_read(const boost::system::error_code& error, 
      const size_t& bytes_transferred) 
     { 
      if (!error) 
      { 
       async_write(upstream_socket_, 
        boost::asio::buffer(downstream_data_, bytes_transferred), 
        boost::bind(&bridge::handle_upstream_write, 
         shared_from_this(), 
         boost::asio::placeholders::error)); 
      } 
      else 
       close(); 
     } 

     void handle_upstream_write(const boost::system::error_code& error) 
     { 
      if (!error) 
      { 
       downstream_socket_.async_read_some(
        boost::asio::buffer(downstream_data_, max_data_length), 
        boost::bind(&bridge::handle_downstream_read, 
         shared_from_this(), 
         boost::asio::placeholders::error, 
         boost::asio::placeholders::bytes_transferred)); 
      } 
      else 
       close(); 
     } 

     void handle_upstream_read(const boost::system::error_code& error, 
      const size_t& bytes_transferred) 
     { 
      if (!error) 
      { 
       async_write(downstream_socket_, 
        boost::asio::buffer(upstream_data_, bytes_transferred), 
        boost::bind(&bridge::handle_downstream_write, 
         shared_from_this(), 
         boost::asio::placeholders::error)); 
      } 
      else 
       close(); 
     } 

     void close() 
     { 
      boost::mutex::scoped_lock lock(mutex_); 

      if (downstream_socket_.is_open()) 
      { 
       downstream_socket_.close(); 
      } 

      if (upstream_socket_.is_open()) 
      { 
       upstream_socket_.close(); 
      } 
     } 

     socket_type downstream_socket_; 
     socket_type upstream_socket_; 

     enum { max_data_length = 8192 }; //8KB 
     unsigned char downstream_data_[max_data_length]; 
     unsigned char upstream_data_[max_data_length]; 

     boost::mutex mutex_; 

    public: 

     class acceptor 
     { 
     public: 

      acceptor(boost::asio::io_service& io_service, 
       const std::string& local_host, unsigned short local_port, 
       const std::string& upstream_host, unsigned short upstream_port) 
       : io_service_(io_service), 
       localhost_address(boost::asio::ip::address_v4::from_string(local_host)), 
       acceptor_(io_service_, ip::tcp::endpoint(localhost_address, local_port)), 
       upstream_port_(upstream_port), 
       upstream_host_(upstream_host) 
      {} 

      bool accept_connections() 
      { 
       try 
       { 
        session_ = boost::shared_ptr<bridge>(new bridge(io_service_)); 

        acceptor_.async_accept(session_->downstream_socket(), 
         boost::bind(&acceptor::handle_accept, 
          this, 
          boost::asio::placeholders::error)); 
       } 
       catch (std::exception& e) 
       { 
        std::cerr << "acceptor exception: " << e.what() << std::endl; 
        return false; 
       } 

       return true; 
      } 

     private: 

      void handle_accept(const boost::system::error_code& error) 
      { 
       if (!error) 
       { 
        session_->start(upstream_host_, upstream_port_); 

        if (!accept_connections()) 
        { 
         std::cerr << "Failure during call to accept." << std::endl; 
        } 
       } 
       else 
       { 
        std::cerr << "Error: " << error.message() << std::endl; 
       } 
      } 

      boost::asio::io_service& io_service_; 
      ip::address_v4 localhost_address; 
      ip::tcp::acceptor acceptor_; 
      ptr_type session_; 
      unsigned short upstream_port_; 
      std::string upstream_host_; 
     }; 

    }; 
} 

int main(int argc, char* argv[]) 
{ 
    if (argc != 5) 
    { 
     std::cerr << "usage: EvilProxy.exe <local host ip> <local port> <forward host ip> <forward port>" << std::endl; 
     return 1; 
    } 

    const unsigned short local_port = static_cast<unsigned short>(::atoi(argv[2])); 
    const unsigned short forward_port = static_cast<unsigned short>(::atoi(argv[4])); 
    const std::string local_host = argv[1]; 
    const std::string forward_host = argv[3]; 

    boost::asio::io_service ios; 

    boost::system::error_code ec; 

    boost::asio::ip::tcp::socket &mySocket = tcp_proxy::bridge(ios).downstream_socket(); 

    try 
    { 

     std::string str_IpDest = mySocket.remote_endpoint().address().to_string(); // Here i try to get the adresse but with this code, the adresse is seeking only at the begining...it's too earl 

     tcp_proxy::bridge::acceptor acceptor(ios, 
      local_host, local_port, 
      str_IpDest, forward_port); 

     acceptor.accept_connections(); 

     ios.run(); 
    } 
    catch (std::exception& e) 
    { 
     std::cerr << "Error: " << e.what() << std::endl; 
     return 1; 
    } 

    return 0; 
} 

私は」： 問題は、私はこれを試してみました...私は、ブラウザ上の別のアドレスを求める「トリガー」するために、この機能のeachtimeの使用をそれを実装する方法がわからない

ですこれを行うと、

しかし、それは伯爵に呼ばれている、私は別のアドレスを尋ねるたびにそれを引き起こす方法を知らない。

私はboost：asioを使用します。

Anyonは私を助けますか？ ゴール...後:)

おかげでたくさんの後にSSLを使用することです...しかし... :)

よろしく

Answer 1

あなたは、ブラウザ間の通信のためのプロトコルのいくつかの種類を必要としますプロキシ最初にあなたのブラウザは "connect to"というメッセージを送る必要があり、接続が成功したらプロキシは情報を送るべきです。私は、HTTPにはプロキシ処理に固有のヘッダーがいくつかあると考えています。