// Updates filter rule arrays with current settings
public void UpdateFilterRules()
{
if (prohibitedList.Count != 0)
{
prohibitedList.Clear();
}
if (permittedList.Count != 0)
{
permittedList.Clear();
}
enableURLFilter = (bool)SEBSettings.settingsCurrent[SEBSettings.KeyURLFilterEnable];
enableContentFilter = (bool)SEBSettings.settingsCurrent[SEBSettings.KeyURLFilterEnableContentFilter];
// Add global URLFilterRules
ListObj URLFilterRules = (ListObj)SEBSettings.settingsCurrent[SEBSettings.KeyURLFilterRules];
ReadURLFilterRules(URLFilterRules);
// Add URLFilterRules from additional resources
ListObj additionalResources = (ListObj)SEBSettings.settingsCurrent[SEBSettings.KeyAdditionalResources];
ReadFilterRulesFromAdditionalResources(additionalResources);
// If URL filtering is enabled, then
// check if Start URL gets allowed by current filter rules and if not add a rule for the Start URL
string startURLString = (string)SEBSettings.settingsCurrent[SEBSettings.KeyStartURL];
if (enableURLFilter && Uri.TryCreate(startURLString, UriKind.Absolute, out Uri startURL))
{
if (TestURLAllowed(startURL) != URLFilterRuleActions.allow)
{
SEBURLFilterRegexExpression expression;
// If Start URL is not allowed: Create one using the full Start URL
try
{
expression = new SEBURLFilterRegexExpression(startURLString);
}
catch (Exception ex)
{
Logger.AddError("Could not create SEBURLFilterRegexExpression: ", this, ex, ex.Message);
prohibitedList.Clear();
permittedList.Clear();
// Convert these rules and add them to the XULRunner seb keys
CreateSebRuleLists();
return;
}
// Add this Start URL filter expression to the permitted filter list
permittedList.Add(expression);
}
}
// Convert these rules and add them to the XULRunner seb keys
CreateSebRuleLists();
}
public void ReadURLFilterRules(ListObj URLFilterRules)
{
foreach (DictObj URLFilterRule in URLFilterRules)
{
if (URLFilterRule.ContainsKey(SEBSettings.KeyURLFilterRuleRegex) && (bool)URLFilterRule[SEBSettings.KeyURLFilterRuleActive] == true)
{
string expressionString = (string)URLFilterRule[SEBSettings.KeyURLFilterRuleExpression];
if (!String.IsNullOrEmpty(expressionString))
{
Object expression;
bool regex = (bool)URLFilterRule[SEBSettings.KeyURLFilterRuleRegex];
try
{
if (regex)
{
expression = new Regex(expressionString, RegexOptions.IgnoreCase);
}
else
{
expression = new SEBURLFilterRegexExpression(expressionString);
}
}
catch (Exception ex)
{
Logger.AddError("Could not create SEBURLFilterRegexExpression: ", this, ex, ex.Message);
prohibitedList.Clear();
permittedList.Clear();
throw;
}
int action = (int)URLFilterRule[SEBSettings.KeyURLFilterRuleAction];
switch (action)
{
case (int)URLFilterRuleActions.block:
prohibitedList.Add(expression);
break;
case (int)URLFilterRuleActions.allow:
permittedList.Add(expression);
break;
}
}
}
}
}
// Method comparing all components of a passed URL with the filter expression
// and returning YES (= allow or block) if it matches
public bool URLMatchesFilterExpression(Uri URLToFilter, SEBURLFilterRegexExpression filterExpression)
{
Regex filterComponent;
// If a scheme is indicated in the filter expression, it has to match
filterComponent = filterExpression.scheme;
UriBuilder urlToFilterParts = new UriBuilder(URLToFilter);
if (filterComponent != null &&
!Regex.IsMatch(URLToFilter.Scheme, filterComponent.ToString(), RegexOptions.IgnoreCase))
{
// Scheme of the URL to filter doesn't match the one from the filter expression: Exit with matching = NO
return(false);
}
string userInfo = URLToFilter.UserInfo;
filterComponent = filterExpression.user;
if (filterComponent != null &&
!Regex.IsMatch(urlToFilterParts.UserName, filterComponent.ToString(), RegexOptions.IgnoreCase))
{
return(false);
}
filterComponent = filterExpression.password;
if (filterComponent != null &&
!Regex.IsMatch(urlToFilterParts.Password, filterComponent.ToString(), RegexOptions.IgnoreCase))
{
return(false);
}
filterComponent = filterExpression.host;
if (filterComponent != null &&
!Regex.IsMatch(URLToFilter.Host, filterComponent.ToString(), RegexOptions.IgnoreCase))
{
return(false);
}
if (filterExpression.port != null && URLToFilter.Port != -1 &&
URLToFilter.Port != filterExpression.port)
{
return(false);
}
filterComponent = filterExpression.path;
if (filterComponent != null &&
!Regex.IsMatch(URLToFilter.AbsolutePath.Trim(new char[] { '/' }), filterComponent.ToString(), RegexOptions.IgnoreCase))
{
return(false);
}
string urlQuery = URLToFilter.GetComponents(UriComponents.Query, UriFormat.Unescaped);
filterComponent = filterExpression.query;
if (filterComponent != null)
{
// If there's a query filter component, then we need to even filter empty URL query strings
// as the filter might either allow some specific queries or no query at all ("?." query filter)
if (urlQuery == null)
{
urlQuery = "";
}
if (!Regex.IsMatch(urlQuery, filterComponent.ToString(), RegexOptions.IgnoreCase))
{
return(false);
}
}
string urlFragment = URLToFilter.GetComponents(UriComponents.Fragment, UriFormat.Unescaped);
filterComponent = filterExpression.fragment;
if (filterComponent != null &&
!Regex.IsMatch(urlFragment, filterComponent.ToString(), RegexOptions.IgnoreCase))
{
return(false);
}
// URL matches the filter expression
return(true);
}