Esempio n. 1
0
        // This event fires in a background thread, so be careful about touching UI buttons, textboxes, etc.
        void listenSocket_OnTaskCompleted(object sender, Chilkat.TaskCompletedEventArgs args)
        {
            if (args.Task.LastMethodSuccess)
            {
                // We'll be acting as an HTTP server.
                // We'll read the incoming HTTP request and send a response.
                Chilkat.Socket httpServerSock = new Chilkat.Socket();

                // Let's inject this Chilkat.Socket object with the results of the task.
                httpServerSock.LoadTaskResult(args.Task);

                // Read the incoming start line..
                string startLine = httpServerSock.ReceiveUntilMatch("\r\n");

                // Read the HTTP request.  We'll read to the first double CRLF, which is to the end of the
                // request header.  This should be all that is coming because the request should be a GET request (i.e. no request body).
                string requestHeader = httpServerSock.ReceiveUntilMatch("\r\n\r\n");

                // The HTTP request's startLine contains the information we need..
                // It looks like this:
                //  GET /?state=ARudjbBgI8FxgNGqEdUsv1TfYL4rAkOdDObQUT-dV8g&code=4/ovg2Tct4_Ct-BUSPnBRKyXJqsO4nGj9FNxqexxD0KK8&authuser=0&session_state=93ef25f6921934eed290ca484acb58653585ee71..bed8&prompt=consent HTTP/1.1

                // Parse the startLine by getting rid of the "GET" and "HTTP/1.1", and making it a URL that we can load into a Chilkat.HttpRequest object.
                string tempUrl = "http://www.anything.com" + startLine.Replace("GET ", "").Replace(" HTTP/1.1", "").Trim();
                Chilkat.HttpRequest tempReq = new Chilkat.HttpRequest();
                tempReq.SetFromUrl(tempUrl);

                string state         = tempReq.GetParam("state");
                string code          = tempReq.GetParam("code");
                string session_state = tempReq.GetParam("session_state");

                // Now send a response..
                string responseString = string.Format("<html><body><ul><li>state: " + state + "<li>code: " + code + "<li>session_state: " + session_state + "</ul></body></html>");
                httpServerSock.SendString(responseString);

                httpServerSock.Close(10);

                fgAppendToErrorLog(startLine + requestHeader + "\r\n----\r\n");

                // Now exchange the code for an access token and a refresh token.
                // (The args.Task.UserData contains the JSON we initially stashed in the Task's UserData property.)
                googleExchangeCodeForToken(code, args.Task.UserData);
            }
            else
            {
                // Failed...
                fgAppendToErrorLog(args.Task.ResultErrorText);
            }
        }
Esempio n. 2
0
        public static void tunnel(int serverPort)
        {
            Chilkat.Socket tunnel = new Chilkat.Socket();

            bool success;

            //  Anything unlocks the component and begins a fully-functional 30-day trial.
            success = tunnel.UnlockComponent("Anything for 30-day trial");
            if (success != true)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            string sshHostname = "172.24.19.18";
            int    sshPort     = 22;

            //  Connect to an SSH server and establish the SSH tunnel:
            success = tunnel.SshOpenTunnel(sshHostname, sshPort);
            if (success != true)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            //  Authenticate with the SSH server via a login/password
            //  or with a public key.
            //  This example demonstrates SSH password authentication.
            success = tunnel.SshAuthenticatePw("rishabh", "root123");
            if (success != true)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            //  OK, the SSH tunnel is setup.  Now open a channel within the tunnel.
            //  Once the channel is obtained, the Socket API may
            //  be used exactly the same as usual, except all communications
            //  are sent through the channel in the SSH tunnel.
            //  Any number of channels may be created from the same SSH tunnel.
            //  Multiple channels may coexist at the same time.

            //  Connect to an NIST time server and read the current date/time
            Chilkat.Socket channel   = null;
            int            maxWaitMs = 4000;
            bool           useTls    = false;

            channel = tunnel.SshOpenChannel("time-c-g.nist.gov", 37, useTls, maxWaitMs);
            if (channel == null)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            //  The time server will send a big-endian 32-bit integer representing
            //  the number of seconds since since 00:00 (midnight) 1 January 1900 GMT.
            //  The ReceiveInt32 method will receive a 4-byte integer, but returns
            //  true or false to indicate success.  If successful, the integer
            //  is obtained via the ReceivedInt property.
            bool bigEndian = true;

            success = channel.ReceiveInt32(bigEndian);
            if (success != true)
            {
                Console.WriteLine(channel.LastErrorText);

                return;
            }

            Chilkat.CkDateTime dt = new Chilkat.CkDateTime();
            dt.SetFromNtpTime(channel.ReceivedInt);

            //  Show the current local date/time
            bool bLocalTime = true;

            Console.WriteLine("Current local date/time: " + dt.GetAsRfc822(bLocalTime));

            bool isSent = channel.SendString("echo hello world");

            if (isSent != true)
            {
                Console.WriteLine(channel.LastErrorText);
                return;
            }

            Console.WriteLine("---- echo hello world ----");

            //  Close the SSH channel.
            success = channel.Close(maxWaitMs);
            if (success != true)
            {
                Console.WriteLine(channel.LastErrorText);

                return;
            }

            //  It is possible to create a new channel from the existing SSH tunnel for the next connection:
            //  Any number of channels may be created from the same SSH tunnel.
            //  Multiple channels may coexist at the same time.
            channel = tunnel.SshOpenChannel("time-a.nist.gov", 37, useTls, maxWaitMs);
            if (channel == null)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            //  Review the LastErrorText to see that the connection was made via the SSH tunnel:
            Console.WriteLine(tunnel.LastErrorText);

            //  Close the connection to time-a.nist.gov.  This is actually closing our channel
            //  within the SSH tunnel, but keeps the tunnel open for the next port-forwarded connection.
            success = channel.Close(maxWaitMs);
            if (success != true)
            {
                Console.WriteLine(channel.LastErrorText);

                return;
            }

            //  Finally, close the SSH tunnel.
            success = tunnel.SshCloseTunnel();
            if (success != true)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            Console.WriteLine("TCP SSH tunneling example completed.");
        }
Esempio n. 3
0
        static void Main(string[] args)
        {
            int responseBytesTotal = 0;
            int sequence = 0, i = 0;

            Socket listenSocket   = InitializeSocketLibrary();
            Socket outboundSocket = InitializeSocketLibrary();

            File.Delete(PacketRealTimeLog);

            // Bind on port 443
            if (listenSocket.BindAndListen(443, 25) != true)
            {
                Console.WriteLine(listenSocket.LastErrorText + "\r\n");
                return;
            }

            Console.WriteLine("[BREACH SSL Relay ready on 443]\n");

            // Keep the proxy up & running
            while (true)
            {
                // Every 1000 closed sockets, force cleanup & garbage collection
                if (++i % 1000 == 0)
                {
                    Console.Write("## RESET CLEANUP...");
                    Thread.Sleep(500);
                    listenSocket.Close(10000);
                    outboundSocket.Close(10000);
                    listenSocket   = InitializeSocketLibrary();
                    outboundSocket = InitializeSocketLibrary();

                    if (!listenSocket.BindAndListen(443, 25))
                    {
                        Console.WriteLine(listenSocket.LastErrorText + "\r\n");
                        return;
                    }

                    GC.WaitForFullGCComplete();
                    Console.WriteLine(" Done!");
                }

                Chilkat.Socket connectedSocket = null;

                // Listen to incoming client
                do
                {
                    try
                    {
                        connectedSocket = listenSocket.AcceptNextConnection(6000000);
                    }
                    catch (System.AccessViolationException e)
                    {
                        connectedSocket = null;
                        Console.WriteLine("## Error (001): " + e);
                        Thread.Sleep(500);
                    }
                } while (connectedSocket == null);


                // Connect to outbound target
                // BLIND SSL Relay (no need to establish a new SSL tunnel)
                if (!outboundSocket.Connect(TargetIP, 443, false, 10000))
                {
                    Console.WriteLine(outboundSocket.LastErrorText + "\r\n");
                    continue;
                }

                //  Set maximum timeouts for reading an writing (in millisec)
                connectedSocket.MaxReadIdleMs = 90000;
                connectedSocket.MaxSendIdleMs = 90000;
                outboundSocket.MaxReadIdleMs  = 90000;
                outboundSocket.MaxSendIdleMs  = 90000;

                int  received        = 0;
                bool receivingClient = false;
                bool receivingServer = false;


                // Main loop for SSL Proxy - Processing and forwarding flows in both
                // directions so long the conneciton is kept alive
                while (true)
                {
                    if (!connectedSocket.IsConnected)
                    {
                        break;
                    }

                    byte[] requestBytes = null;

                    if (!receivingClient)
                    {
                        receivingClient = true;

                        try
                        {
                            if (!connectedSocket.AsyncReceiveBytes())
                            {
                                Console.WriteLine(connectedSocket.LastErrorText + "\r\n");
                                Thread.Sleep(100);
                                break;
                            }
                        }
                        catch (AccessViolationException e)
                        {
                            Console.WriteLine("## Error (002): " + e);
                            Thread.Sleep(100);
                            break;
                        }
                    }

                    // Request starts here, receive from client
                    if (receivingClient &&
                        connectedSocket.AsyncReceiveFinished)
                    {
                        receivingClient = false;
                        requestBytes    = connectedSocket.AsyncReceivedBytes;
                        if (requestBytes != null && requestBytes.Length > 0)
                        {
                            Console.WriteLine(" >>> rcv: " + responseBytesTotal);

                            if (responseBytesTotal != 0 &&
                                File.Exists(PacketRealTimeLog))
                            {
                                // Since we are detecting a new request and HTTP is synchronous, we now know the previous
                                // response has completed, and we measure the aggregated byte count for all its packets
                                LogPacketLength(PacketRealTimeLog, "--- " + responseBytesTotal,
                                                FileMode.Append, FileAccess.Write, FileShare.Read);

                                Console.WriteLine("\n----------------\n");
                            }


                            // Relay bytes to target server
                            if (!outboundSocket.SendBytes(requestBytes))
                            {
                                Console.WriteLine(connectedSocket.LastErrorText + "\r\n");
                                Thread.Sleep(100);
                                break;
                            }
                        }
                    }


                    // Response starts here
                    byte[] responseBytes = null;

                    if (!receivingServer)
                    {
                        receivingServer = true;

                        try
                        {
                            if (!outboundSocket.AsyncReceiveBytes())
                            {
                                Console.WriteLine("## Error (004) " + outboundSocket.LastErrorText + "\r\n");
                                Thread.Sleep(100);
                                continue;
                            }
                        }
                        catch (System.AccessViolationException e)
                        {
                            Console.WriteLine("## Error (003): " + e);
                            Thread.Sleep(100);
                            break;
                        }
                    }

                    // Write to log file
                    if (receivingServer &&
                        outboundSocket.AsyncReceiveFinished)
                    {
                        receivingServer = false;
                        responseBytes   = outboundSocket.AsyncReceivedBytes;

                        if (responseBytes != null && responseBytes.Length > 0)
                        {
                            received += responseBytes.Length;
                            Console.WriteLine("<<" + responseBytes.Length);
                            sequence++;

                            // Real time packet log (logging each individual packet length for BREACH)
                            LogPacketLength(PacketRealTimeLog, sequence + " " + responseBytes.Length,
                                            FileMode.Append, FileAccess.Write, FileShare.Read);


                            Console.Title       = "received: " + received;
                            responseBytesTotal += responseBytes.Length;

                            // Relay to client
                            if (!connectedSocket.SendBytes(responseBytes))
                            {
                                Console.WriteLine("## Error (005) " + connectedSocket.LastErrorText + "\r\n");
                                Thread.Sleep(100);
                                break;
                            }
                        }

                        else if (connectedSocket.IsConnected &&
                                 !outboundSocket.IsConnected)
                        {
                            // We lost one socket, kill it with fire
                            connectedSocket.Close(10000);
                            break;
                        }
                    }
                }

                // Log for non-Keep-Alive cases (Connection Closed)
                LogPacketLength(PacketLengthLog, received.ToString(),
                                FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);


                //  Close the connection with the client.
                outboundSocket.Close(10000);
                connectedSocket.Close(10000);
                Console.WriteLine("Socket Closed < " + received);
            }
        }