Example #1
0
        public static void Show(CoreAccessRequestedEventArgs e)
        {
            var frm = new FormAccessRequest(e);

            DialogResult res = frm.ShowDialog();

            if (res == DialogResult.Yes)
            {
                e.Allow = true;
            }
            else if (res == DialogResult.No)
            {
                e.Allow = false;
            }
            else if (res == DialogResult.OK) //Create rule.
            {
                e.CreateRule   = true;
                e.CategoryName = "User Created Rules";
                e.ItemName     = "User Created Rules";
                e.RuleName     = Path.GetFileName(e.ProtectedPath) + " for " +
                                 Path.GetFileName(e.ProcessPath);

                if (frm.radioAllow.Checked)
                {
                    e.Allow = true;
                }
                else if (frm.radioBlock.Checked)
                {
                    e.Allow = false;
                }
            }
        }
Example #2
0
 public FormAccessRequest(CoreAccessRequestedEventArgs e)
     : this()
 {
     labelProcessPath.Text   = e.ProcessPath;
     labelOperation.Text     = e.OperationName;
     labelProtectedPath.Text = e.ProtectedPath;
 }
Example #3
0
        private void button1_Click(object sender, EventArgs e)
        {
            var ea = new CoreAccessRequestedEventArgs("TestOperation", "TestPath", "TestProcess");

            ea.Allow = false;

            Interface.OnAccessRequested(ea);

            if (ea.Allow == false)
            {
                MessageBox.Show("Allow is false!");
            }
        }
Example #4
0
        public void WaitRequest()
        {
            if (!_IsStarted)
            {
                throw new InvalidOperationException("Can't execute while Core is stopped.");
            }

            var request = _Driver.GetRequest();
            var allow   = false;

            Ruleset.RulesRow rule;
            if (Ruleset.Processes.FindByPath(request.ProcessPath) != null)
            {
                rule = Ruleset.GetRulesRow(request.RuleID, request.ProcessPath);
                if (rule == null && Ruleset.Processes.FindByPath("*") != null)
                {
                    rule = Ruleset.GetRulesRow(request.RuleID, "*");
                }
            }
            else if (Ruleset.Processes.FindByPath("*") != null)
            {
                rule = Ruleset.GetRulesRow(request.RuleID, "*");
            }
            else
            {
                rule = null;
            }

            if (rule == null) // No rule found - just allow this request.
            {
                allow = true;
            }
            else
            {
                if (rule.Action == RuleAction.Allow)
                {
                    allow = true;
                }
                else if (rule.Action == RuleAction.Block)
                {
// ReSharper disable RedundantAssignment
                    allow = false;
                }
// ReSharper restore RedundantAssignment
                else if (rule.Action == RuleAction.Ask)
                {
                    var ea = new CoreAccessRequestedEventArgs("", request.Path, request.ProcessPath);
                    _ServiceInterface.OnAccessRequested(ea);
                    allow = ea.Allow;

                    if (ea.CreateRule)
                    {
                        var processRow = Ruleset.Processes.FindByPath(request.ProcessPath) ??
                                         Ruleset.Processes.AddProcessesRow(request.ProcessPath);

                        if (rule.ProcessPath == "*")
                        {
                            var newRule = Ruleset.GetRulesRow(request.RuleID, request.ProcessPath);
                            if (newRule == null)
                            {
                                Ruleset.Rules.AddRulesRow(
                                    (allow ? "Allow" : "Block") + " access to " + Path.GetFileName(request.Path) +
                                    " for " +
                                    Path.GetFileName(request.ProcessPath),
                                    RuleAction.FromBoolean(allow),
                                    true,
                                    rule.PathsRow,
                                    processRow,
                                    rule.ItemsRow);
                            }
                            else
                            {
                                newRule.Action = RuleAction.FromBoolean(allow);
                            }
                        }
                        else
                        {
                            rule.Action = RuleAction.FromBoolean(allow);
                        }
                    }
                }
            }

            IncrementCounter(request.AccessType, allow);

            // Log the data about request to event log.
            if ((rule == null || rule.Log) && _EventLog != null)
            {
                var entryData =
                    new LogEntryData(DateTime.Now.ToLongDateString() + " " + DateTime.Now.ToShortTimeString(),
                                     allow, (AccessType)request.AccessType, request.Path, request.ProcessPath);
                _EventLog.WriteEntry("Please use FileWall to view this log.", EventLogEntryType.Information, 0, 0, LogEntryData.Serialize(entryData));
            }

            _Driver.ReplyRequest(request, allow);
        }
Example #5
0
 private static void AccessRequested(object sender, CoreAccessRequestedEventArgs ea)
 {
     FormAccessRequest.Show(ea);
 }
Example #6
0
 static void serviceInterface_AccessRequested(object sender, CoreAccessRequestedEventArgs e)
 {
     e.Allow = true;
     MessageBox.Show("AccessRequested", "Client");
 }