Example #1
0
        static void Main(string[] args)
        {
            Chilkat.Global glob    = new Chilkat.Global();
            bool           success = glob.UnlockBundle("Anything for 30-day trial");

            if (success != true)
            {
                Debug.WriteLine(glob.LastErrorText);
                return;
            }

            int status = glob.UnlockStatus;

            if (status == 2)
            {
                Debug.WriteLine("Unlocked using purchased unlock code.");
            }
            else
            {
                Debug.WriteLine("Unlocked in trial mode.");
            }

            // The LastErrorText can be examined in the success case to see if it was unlocked in
            // trial more, or with a purchased unlock code.
            Debug.WriteLine(glob.LastErrorText);

            var certPath = $@"{AppDomain.CurrentDomain.BaseDirectory}server_20110101.pfx";

            var server          = "83.220.246.39";
            var port            = 9000;
            var maxWaitMillisec = 10000;

            //var certPass = "******";

            using (var socket = new Chilkat.Socket
            {
                SocksHostname = server,
                SocksPort = port,
                SocksUsername = "******",
                SocksPassword = "******",
                SocksVersion = 5,
                MaxReadIdleMs = maxWaitMillisec,
                MaxSendIdleMs = maxWaitMillisec
            })
            {
                var cert = new Chilkat.Cert();
                cert.LoadFromFile(certPath);

                socket.SetSslClientCert(cert);

                socket.Connect(server, port, true, maxWaitMillisec);

                var receivedString = socket.ReceiveString();

                Console.WriteLine(receivedString ?? "none");
            }
        }
Example #2
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);
            }
        }
        /// <summary>
        /// https://www.example-code.com/dotnet-core/dnsLookup.asp
        /// </summary>
        /// <param name="target"></param>
        /// <returns></returns>
        public async Task <NetworkDnsQueryLookup> DnsChilkatLookup(string target)
        {
            Chilkat.Socket socket = new Chilkat.Socket();
            socket.UnlockComponent("unlock_code");

            int milliseconds = 10000;

            var address = await Task.Run(() => { return(socket.DnsLookup(target, milliseconds)); });

            var networkDnsQueryLookup = new NetworkDnsQueryLookup
            {
                IpAddress = address,
            };

            Debug.Assert(!string.IsNullOrEmpty(networkDnsQueryLookup.IpAddress), "IP Address empty? Why?");

            if (!socket.LastMethodSuccess)
            {
                Debug.WriteLine(socket.LastErrorText);
                return(default);
Example #4
0
        // URLs to help understand this topic:
        // https://developers.google.com/identity/protocols/OAuth2InstalledApp
        //
        private bool oauth2_google(string scope)
        {
            // Generates state and PKCE values.
            string state         = m_prng.GenRandom(32, base64Url);
            string code_verifier = m_prng.GenRandom(32, base64Url);

            Chilkat.Crypt2 crypt = new Chilkat.Crypt2();
            crypt.EncodingMode  = base64Url;
            crypt.HashAlgorithm = "SHA256";
            string       code_challenge        = crypt.HashStringENC(code_verifier);
            const string code_challenge_method = "S256";

            //Create a Chilkat socket for listening.  Begin listening asynchronously.
            Chilkat.Socket listenSocket = new Chilkat.Socket();
            int            backlog      = 5;
            int            listenPort   = 0;

            // Passing a listenPort = 0 causes BindAndListen to find a random unused port.
            // The chosen port will be available via the ListenPort property.
            if (!listenSocket.BindAndListen(listenPort, backlog))
            {
                fgAppendToErrorLog(listenSocket.LastErrorText);
                popupError("Failed to BindAndListen");
                return(false);
            }

            // Get the chosen listen port
            // This ListenPort property is available starting in Chilkat v9.5.0.59
            listenPort = listenSocket.ListenPort;

            // Creates a redirect URI using an available port on the loopback address.
            string redirect_uri = "http://127.0.0.1:" + listenPort.ToString() + "/";

            //Wait a max of 5 minutes.  The OnTaskCompleted event is called when an incoming connection
            //arrives, or when the listen failed.
            listenSocket.OnTaskCompleted += listenSocket_OnTaskCompleted;
            Chilkat.Task task = listenSocket.AcceptNextConnectionAsync(5 * 60000);
            if (task == null)
            {
                MessageBox.Show("Failed to start socket accept...");
                return(false);
            }

            // Add some information that will be needed by the TaskCompleted event..
            Chilkat.JsonObject taskData = new Chilkat.JsonObject();
            taskData.AppendString("code_verifier", code_verifier);
            taskData.AppendString("redirect_uri", redirect_uri);
            task.UserData = taskData.Emit();

            // Start the task.
            task.Run();

            // Creates the OAuth 2.0 authorization request.
            Chilkat.StringBuilder sbAuthRequest = new Chilkat.StringBuilder();
            sbAuthRequest.Append(authorizationEndpoint);
            sbAuthRequest.Append("?response_type=code&scope=");
            sbAuthRequest.Append(m_encoder.EncodeString(scope, "utf-8", "url"));
            sbAuthRequest.Append("&redirect_uri=");
            sbAuthRequest.Append(m_encoder.EncodeString(redirect_uri, "utf-8", "url"));
            sbAuthRequest.Append("&client_id=");
            sbAuthRequest.Append(googleAppClientId);
            sbAuthRequest.Append("&state=");
            sbAuthRequest.Append(state);
            sbAuthRequest.Append("&code_challenge=");
            sbAuthRequest.Append(code_challenge);
            sbAuthRequest.Append("&code_challenge_method=");
            sbAuthRequest.Append(code_challenge_method);

            // Here is a shorter way of building the URL in C#
            //string authorizationRequest = string.Format("{0}?response_type=code&scope={6}&redirect_uri={1}&client_id={2}&state={3}&code_challenge={4}&code_challenge_method={5}",
            //    authorizationEndpoint,  // 0
            //    System.Uri.EscapeDataString(redirect_uri), // 1
            //    googleAppClientId, // 2
            //    state, // 3
            //    code_challenge, // 4
            //    code_challenge_method, // 5
            //    System.Uri.EscapeDataString(scope)); // 6

            // Get authorization from Google account owner...
            webBrowser1.Navigate(sbAuthRequest.GetAsString());

            return(true);
        }
Example #5
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.");
        }
Example #6
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);
            }
        }