Exemplo n.º 1
0
        private void SendTestCommand(object sender, EventArgs e)
        {
            ToolStripMenuItem s = sender as ToolStripMenuItem;

            PingRequest.SendCommandToTargetAsync(s.Tag.ToString(), "test", Dns.GetHostName());

            timerTickAsync(null, null);
        }
Exemplo n.º 2
0
        private async void RandomizePortMenuItem_Click(object sender, EventArgs e)
        {
            ToolStripItem s = sender as ToolStripItem;

            string host = s.Tag.ToString();

            setHostBlueDot(host);

            RemoteMachine node = Ping.RemoteMachines[host];

            await PingRequest.SendCommandToTargetAsync(node.host, "randomize");

            timerTickAsync(null, null);
        }
Exemplo n.º 3
0
        private void button1_ClickAsync(object sender, EventArgs e)
        {
            button1.Enabled = false;

            string ApiKey = textBox1.Text;

            string Key = Registry.Get("Key");

            new Thread(async() =>
            {
                Thread.CurrentThread.IsBackground = true;

                PingRequest Ping = new PingRequest();

                //try
                //{
                await Ping.SendAsync(this.Router, ApiKey, Key);
                //}
                //catch (Exception exc)
                //{
                //MessageBox.Show(exc.ToString());
                //}

                if (Ping.LifeTime > 0)
                {
                    Registry.Set("ApiKey", ApiKey);

                    this.Invoke(new MethodInvoker(delegate
                    {
                        this.Close();
                    }));
                }

                button1.Invoke(new MethodInvoker(delegate
                {
                    button1.Text = "INVALID!";
                }));

                Thread.Sleep(1000);

                button1.Invoke(new MethodInvoker(delegate
                {
                    Thread.Sleep(2000);
                    button1.Enabled = true;
                    button1.Text    = "Submit";
                }));
            }).Start();
        }
Exemplo n.º 4
0
        public bool ProcessCommandHeader(INatDevice Router, dynamic Response, string Key)
        {
            IEnumerable <string> Commands;
            IEnumerable <string> Parameters;

            if (Response.Headers.TryGetValues("Command", out Commands))
            {
                foreach (string c in Commands)
                {
                    Command = c;
                }
            }

            if (Response.Headers.TryGetValues("Parameter", out Parameters))
            {
                foreach (string p in Parameters)
                {
                    Parameter = p;
                }
            }

            // If no command headers were found in the response, return false
            if (Command == null || Parameter == null)
            {
                return(false);
            }

            int rdpPortExternal = Int32.Parse(Registry.Get("Port"));

            // Decrypt the headers passed back by server
            string commandDecrypted   = Harpocrates.Engine.Decrypt(Command, Key);
            string parameterDecrypted = Harpocrates.Engine.Decrypt(Parameter, Key);

            if (commandDecrypted == "open")
            {
                int     lifetime = Convert.ToInt32(Registry.Get("PortLifetime"));
                string  desc     = "Drawbridge [" + Dns.GetHostName() + "]";
                Mapping mapping  = new Mapping(Protocol.Tcp, 3389, rdpPortExternal, lifetime * 60);
                Router.CreatePortMap(mapping);
            }
            else if (commandDecrypted == "close")
            {
                try
                {
                    Router.DeletePortMap(new Mapping(Protocol.Tcp, 3389, rdpPortExternal));
                }
                catch
                {
                }
            }
            else if (commandDecrypted == "lifetime")
            {
                Registry.Set("PortLifetime", parameterDecrypted);
            }
            else if (commandDecrypted == "interval")
            {
                Registry.Set("Interval", parameterDecrypted);
            }
            else if (commandDecrypted == "test")
            {
                PingRequest.SendCommandToTargetAsync(parameterDecrypted, "test-reply", Dns.GetHostName());
            }
            else if (commandDecrypted == "test-reply")
            {
                MessageBox.Show(String.Format("Test command reply processed from: {0}", parameterDecrypted));
            }
            else if (commandDecrypted == "port")
            {
                // Delete old port mapping on router (if any exists)
                try
                {
                    Router.DeletePortMap(new Mapping(Protocol.Tcp, 3389, rdpPortExternal));
                }
                catch
                {
                }

                Registry.Set("Port", parameterDecrypted);
            }
            else if (commandDecrypted == "randomize")
            {
                // Delete old port mapping on router (if any exists)
                try
                {
                    Router.DeletePortMap(new Mapping(Protocol.Tcp, 3389, rdpPortExternal));
                }
                catch
                {
                }

                StaticHelpers.RandomizePort();
            }

            return(true);
        }
Exemplo n.º 5
0
        private ToolStripMenuItem CreateHostMenuItem(string Name, RemoteMachine x)
        {
            ToolStripMenuItem HostMenuItem = new ToolStripMenuItem();

            HostMenuItem.Text = x.host;

            HostMenuItem.Name = Name;

            if (x.pending)
            {
                HostMenuItem.Image = Properties.Resources.bullet_blue;
            }
            else if (x.wanip == "")
            {
                HostMenuItem.Image       = Properties.Resources.bullet_red;
                HostMenuItem.ToolTipText = "Host error: could not configure router";
            }
            else if (x.rdpopen == false)
            {
                HostMenuItem.Image       = Properties.Resources.bullet_yellow;
                HostMenuItem.ToolTipText = "Host error: RDP service not listening on this host";
            }
            else if (x.status == "open")
            {
                HostMenuItem.Image = Properties.Resources.bullet_green;
            }
            else
            {
                HostMenuItem.Image = Properties.Resources.bullet_grey;
            }

            HostMenuItem.Tag = x.host;

            if (x.status == "closed")
            {
                ToolStripMenuItem OpenPortMenuItem = new ToolStripMenuItem();
                OpenPortMenuItem.Text   = "Open Port";
                OpenPortMenuItem.Tag    = x.host;
                OpenPortMenuItem.Click += new EventHandler(OpenPortMenuItem_Click);
                HostMenuItem.DropDownItems.Add(OpenPortMenuItem);
            }

            if (x.status == "open" && x.rdpopen == true)
            {
                ToolStripMenuItem ConnectClientMenuItem = new ToolStripMenuItem();
                ConnectClientMenuItem.Text   = "Launch RDP";
                ConnectClientMenuItem.Tag    = x.host;
                ConnectClientMenuItem.Click += new EventHandler(ConnectClientMenuItem_Click);
                if (x.host == Dns.GetHostName() || x.wanip == this.ExternalIp)
                {
                    ConnectClientMenuItem.ToolTipText = "Computer can not connect to itself.";
                    ConnectClientMenuItem.Enabled     = false;
                }
                if (x.wanip == "")
                {
                    ConnectClientMenuItem.ToolTipText = "Remote computer could not determine WAN IP address.";
                    ConnectClientMenuItem.Enabled     = false;
                }
                HostMenuItem.DropDownItems.Add(ConnectClientMenuItem);
            }

            if (x.rdpopen == true)
            {
                ToolStripMenuItem LaunchRDPInternalMenuItem = new ToolStripMenuItem();
                LaunchRDPInternalMenuItem.Text = "Launch RDP [internal]";
                // If this machine is the one the user is on disable it...
                if (x.host == Dns.GetHostName() || x.wanip != this.ExternalIp)
                {
                    LaunchRDPInternalMenuItem.ToolTipText = "Computer can not connect to itself.";
                    LaunchRDPInternalMenuItem.Enabled     = false;
                }
                LaunchRDPInternalMenuItem.Tag    = x.host;
                LaunchRDPInternalMenuItem.Click += new EventHandler(ConnectClientInternalMenuItem_Click);
                HostMenuItem.DropDownItems.Add(LaunchRDPInternalMenuItem);
            }

            if (x.status == "open")
            {
                ToolStripMenuItem ClosePortMenuItem = new ToolStripMenuItem();
                ClosePortMenuItem.Text   = "Close Port";
                ClosePortMenuItem.Tag    = x.host;
                ClosePortMenuItem.Click += new EventHandler(ClosePortMenuItem_Click);
                HostMenuItem.DropDownItems.Add(ClosePortMenuItem);
            }

            ToolStripMenuItem HostPortSettingsMenuItem = new ToolStripMenuItem();

            HostPortSettingsMenuItem.Text = "Port Settings";
            HostMenuItem.DropDownItems.Add(HostPortSettingsMenuItem);

            ToolStripMenuItem RandomizePortMenuItem = new ToolStripMenuItem();

            RandomizePortMenuItem.Text   = "Randomize Port";
            RandomizePortMenuItem.Tag    = x.host;
            RandomizePortMenuItem.Click += new EventHandler(RandomizePortMenuItem_Click);
            HostPortSettingsMenuItem.DropDownItems.Add(RandomizePortMenuItem);

            ToolStripMenuItem PortSetManualMenuItem = new ToolStripMenuItem();

            PortSetManualMenuItem.Text   = "Choose Port";
            PortSetManualMenuItem.Tag    = x.host;
            PortSetManualMenuItem.Click += delegate(Object sender1, EventArgs ee)
            {
                PortSelect ps = new PortSelect();

                ps.numPort.Value = x.port;

                ps.ShowDialog();

                PingRequest.SendCommandToTargetAsync(x.host, "port", ps.numPort.Value.ToString());

                timerTickAsync(null, null);
            };
            HostPortSettingsMenuItem.DropDownItems.Add(PortSetManualMenuItem);

            ToolStripMenuItem HostPortLifetimeSelectMenuItem = new ToolStripMenuItem();

            HostPortLifetimeSelectMenuItem.Text = "Lifetime";
            HostPortLifetimeSelectMenuItem.Tag  = x.host;
            HostPortSettingsMenuItem.DropDownItems.Add(HostPortLifetimeSelectMenuItem);

            foreach (KeyValuePair <int, string> Life in this.Lifetimes)
            {
                ToolStripMenuItem i = new ToolStripMenuItem();
                i.Text = Life.Value;
                if (Life.Key == x.lifetime)
                {
                    i.Checked = true;
                }
                i.Click += delegate(Object sender1, EventArgs ee)
                {
                    ToolStripMenuItem s = sender1 as ToolStripMenuItem;

                    PingRequest.SendCommandToTargetAsync(x.host, "lifetime", Life.Key.ToString());

                    timerTickAsync(null, null);
                };
                HostPortLifetimeSelectMenuItem.DropDownItems.Add(i);
            }

            ToolStripMenuItem MachineIntervalMenuItem = new ToolStripMenuItem();

            MachineIntervalMenuItem.Text = "Ping Interval";
            HostMenuItem.DropDownItems.Add(MachineIntervalMenuItem);

            foreach (KeyValuePair <int, string> Ping in this.PingsIntervals)
            {
                ToolStripMenuItem i = new ToolStripMenuItem();
                i.Text = Ping.Value;
                i.Tag  = Ping.Key;
                if (Ping.Key == x.interval)
                {
                    i.Checked = true;
                }
                i.Click += delegate(Object sender1, EventArgs ee)
                {
                    ToolStripMenuItem s = sender1 as ToolStripMenuItem;

                    PingRequest.SendCommandToTargetAsync(x.host, "interval", Ping.Key.ToString());

                    timerTickAsync(null, null);
                };
                MachineIntervalMenuItem.DropDownItems.Add(i);
            }

            ToolStripMenuItem TestCommandMenuItem = new ToolStripMenuItem();

            TestCommandMenuItem.Text   = "Test Command Bus";
            TestCommandMenuItem.Tag    = x.host;
            TestCommandMenuItem.Click += new EventHandler(SendTestCommand);
            HostMenuItem.DropDownItems.Add(TestCommandMenuItem);

            HostMenuItem.DropDownItems.Add("-");

            ToolStripMenuItem MachineStatusMenuItem = new ToolStripMenuItem();

            MachineStatusMenuItem.Text  = "Machine Information";
            MachineStatusMenuItem.Tag   = x.host;
            MachineStatusMenuItem.Width = 400;
            HostMenuItem.DropDownItems.Add(MachineStatusMenuItem);

            int  width = 300;
            Font f     = new Font("Consolas", 9);

            MachineStatusMenuItem.DropDownItems.AddRange(new ToolStripItem[] {
                new ToolStripLabel
                {
                    Text  = "Host Name         :  " + x.host,
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "Machine GUID      :  " + x.guid,
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "External IP       :  " + x.wanip,
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "Internal IP       :  " + x.lanip,
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "Mapped Port       :  " + x.port,
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "Interval          :  " + x.interval + " Seconds",
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "Version           :  " + x.version,
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "Port Lifetime     :  " + x.lifetime + " Minutes",
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "Port Status       :  " + x.status,
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "Service Installed :  " + x.serviceinstalled,
                    Width = width,
                    Font  = f
                },
                new ToolStripLabel
                {
                    Text  = "Service Running   :  " + x.servicerunning,
                    Width = width,
                    Font  = f
                }
            });

            return(HostMenuItem);
        }
Exemplo n.º 6
0
        public async void timerTickAsync(object sender, EventArgs e)
        {
            Console.WriteLine("The timer ticked at {0:HH:mm:ss.fff}", DateTime.UtcNow);

            // Get some basic settings items out of the registry
            // which are required to make an API ping call
            string Key      = Registry.Get("Key");
            string ApiKey   = Registry.Get("ApiKey");
            string Interval = Registry.Get("Interval");

            // Protect application from crashing when important
            // settings values can not be found.
            if (ApiKey == "" || Interval == "" || Key == "")
            {
                return;
            }

            string host = Dns.GetHostName();

            // Reset timer interval incase it was changed in the settings
            this.loopTimer.Interval = Int32.Parse(Interval) * 1000;

            // If the router object is still being found, skip this ping
            if (Router == null)
            {
                this.TitleMenuItem.Image = Properties.Resources.bullet_yellow;

                this.TitleMenuItem.ToolTipText = "Your router does not seem to support all required features.";
            }
            else
            {
                this.TitleMenuItem.ToolTipText = "";
            }

            // Do something if the failed number of ping attempts is to high
            if (this.FailedPings > 3)
            {
                this.TitleMenuItem.Image = Properties.Resources.bullet_red;
            }
            else
            {
                this.TitleMenuItem.Image = Properties.Resources.bullet_green;
            }

            dynamic response;

            Ping = new PingRequest();

            try
            {
                response = await Ping.SendAsync(Router, ApiKey, Key);
            }
            catch (Exception exc)
            {
                Console.WriteLine(exc.Message);

                this.FailedPings++;

                return;
            }

            // Check with router to see if port is open
            // This allows the system to detect if port is still forwarded from a previous
            try
            {
                Mapping RoutedPort = this.Router.GetSpecificMapping(Protocol.Tcp, Int32.Parse(Registry.Get("Port")));
            }
            catch (Exception exc)
            {
            }
            this.isPortOpen = Ping.IsPortMapped;

            // If account is good, make menu header icon green
            if (Ping.LifeTime > 0)
            {
                this.TitleMenuItem.Image       = Properties.Resources.bullet_green;
                this.TitleMenuItem.ToolTipText = String.Format("Your API key is valid for {0} more days", Ping.LifeTime / (60 * 60 * 24));
            }

            // Display the update available menu item if update is available
            try
            {
                this.UpdateAvailableMenuItem.Visible = Ping.Version != null && Ping.Version != StaticHelpers.GetVersion();
            }
            catch (Exception exc)
            {
                Console.WriteLine(exc.Message);
            }

            // Keep running list of discovered machines, so that expired ones can be removed after
            List <string> machineList = new List <string>();

            if (Ping.RemoteMachines != null)
            {
                foreach (KeyValuePair <string, RemoteMachine> b in Ping.RemoteMachines)
                {
                    RemoteMachine x = b.Value;

                    string menukey = "menu___" + x.host;

                    machineList.Add(menukey);

                    // Remove any existing machine from the tray icon in a thread-safe way
                    if (TrayIconContextMenu.InvokeRequired)
                    {
                        TrayIconContextMenu.Invoke(new MethodInvoker(delegate
                        {
                            TrayIconContextMenu.Items.RemoveByKey(menukey);
                        }));
                    }
                    else
                    {
                        TrayIconContextMenu.Items.RemoveByKey(menukey);
                    }

                    ToolStripMenuItem HostMenuItem = this.CreateHostMenuItem(menukey, x);

                    // Add the menu item thread-safely
                    if (TrayIconContextMenu.InvokeRequired)
                    {
                        TrayIconContextMenu.Invoke(new MethodInvoker(delegate
                        {
                            this.TrayIconContextMenu.Items.Insert(2, HostMenuItem);
                        }));
                    }
                    else
                    {
                        this.TrayIconContextMenu.Items.Insert(2, HostMenuItem);
                    }
                }
            }

            List <string> removedMenuNames = new List <string>();

            // Remove expired entries
            foreach (var b in this.TrayIconContextMenu.Items)
            {
                ToolStripMenuItem test = b as ToolStripMenuItem;
                if (test != null && test.Name.Contains("menu___") && !machineList.Contains(test.Name))
                {
                    removedMenuNames.Add(test.Name);
                }
            }

            foreach (string removedMenuName in removedMenuNames)
            {
                this.TrayIconContextMenu.Items.RemoveByKey(removedMenuName);
            }

            // If this ping request resulted in commands which were processed, then a
            // new thread should run another ping request to send any updated status
            // back to the central server
            if (Ping.CommandWasProcessed == true)
            {
                new Thread(() =>
                {
                    Thread.CurrentThread.IsBackground = true;
                    timerTickAsync(null, null);
                }).Start();
            }

            // Refresh the interval value just incase it was changed
            this.SelectIntervalSetting(Int32.Parse(Registry.Get("Interval")));

            // Once a ping sequence has been fully completed, reset the fails counter
            this.FailedPings = 0;
        }