Results 1 to 3 of 3
  1. #1
    awesomediamond's Avatar
    Join Date
    Oct 2013
    Gender
    male
    Posts
    105
    Reputation
    10
    Thanks
    2
    My Mood
    Busy

    Does anyone have a script that lets proxies constantly join a link

    I was wondering if someone has one of these scripts or can help me make one since my friend recently had one of these and I found it really cool because it helped me get something I needed on a website and I was wondering if this has been posted on mpgh before or not

  2. #2
    Dogecoin's Avatar
    Join Date
    Mar 2013
    Gender
    male
    Posts
    219
    Reputation
    15
    Thanks
    29
    My Mood
    Devilish
    By this you mean a program that connects to a proxy and visits a website?
    Official KIK: KIK.me/eco
    I do not currently have a SKYPE. Careful of impostors.
    Best Proxies Ever: https://www.mpgh.net/forum/showthread.php?t=1250977

  3. #3
    Hackinet's Avatar
    Join Date
    Jun 2014
    Gender
    male
    Posts
    348
    Reputation
    126
    Thanks
    703
    My Mood
    Stressed
    Quote Originally Posted by awesomediamond View Post
    I was wondering if someone has one of these scripts or can help me make one since my friend recently had one of these and I found it really cool because it helped me get something I needed on a website and I was wondering if this has been posted on mpgh before or not
    Is this what you want?
    Code:
    //
    // tcpproxy_server.cpp
    // ~~~~~~~~~~~~~~~~~~~
    //
    // Copyright (c) 2007 Arash Partow (https://www.partow.net)
    // URL: https://www.partow.net/programming/tcpproxy/index.html
    //
    // Distributed under the Boost Software License, Version 1.0.
    //
    //
    // Description
    // ~~~~~~~~~~~
    // The objective of the TCP proxy server is to act as an intermediary
    // in order to 'forward' TCP based connections from external clients
    // onto a singular remote server.
    // The communication flow in the direction from the client to the proxy
    // to the server is called the upstream flow, and the communication flow
    // in the direction from the server to the proxy to the client is called
    // the downstream flow. Furthermore the up and down stream connections
    // are consolidated into a single concept known as a bridge.
    // In the event either the downstream or upstream end points disconnect,
    // the proxy server will proceed to disconnect the other end point
    // and eventually destroy the associated bridge.
    //
    // The following is a flow and structural diagram depicting the
    // various elements (proxy, server and client) and how they connect
    // and interact with each other.
    //
    //                                    ---> upstream --->           +---------------+
    //                                                     +---->------>               |
    //                               +-----------+         |           | Remote Server |
    //                     +--------->          [x]--->----+  +---<---[x]              |
    //                     |         | TCP Proxy |            |        +---------------+
    // +-----------+       |  +--<--[x] Server   <-----<------+
    // |          [x]--->--+  |      +-----------+
    // |  Client   |          |
    // |           <-----<----+
    // +-----------+
    //                <--- downstream <---
    //
    //
    
    
    #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;
    }
    
    /*
     * [Note] On posix systems the tcp proxy server build command is as follows:
     * c++ -pedantic -ansi -Wall -Werror -O3 -o tcpproxy_server tcpproxy_server.cpp -L/usr/lib -lstdc++ -lpthread -lboost_thread -lboost_system
     */


    --------

  4. The Following 3 Users Say Thank You to Hackinet For This Useful Post:

    prohacku (06-15-2017),thxtesting (06-15-2017),thxtesting2 (06-15-2017)

Similar Threads

  1. Does anyone have any hacks that work for CA atm?like chams simply for NA
    By XxX_Hacker_XxX in forum Combat Arms Hack Requests
    Replies: 2
    Last Post: 10-26-2013, 07:44 AM
  2. [Help Request] anyone have a script that disables a players controls?
    By mrtangothemango in forum DayZ Help & Requests
    Replies: 6
    Last Post: 03-27-2013, 07:33 PM
  3. Does anyone have a hack that work for vista??
    By ryantjuh98 in forum Combat Arms Europe Hacks
    Replies: 14
    Last Post: 05-02-2009, 03:00 AM
  4. Replies: 17
    Last Post: 04-05-2009, 02:29 PM
  5. Does anyone have map.wz that has not been touched?
    By yaowings in forum MapleStory Hacks, Cheats & Trainers
    Replies: 2
    Last Post: 04-03-2009, 03:15 PM