WebApplicationFirewall.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Schema;
using Waher.Content.Xml;
using Waher.Content.Xsl;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Networking.HTTP.Interfaces;
using Waher.Runtime.Cache;
using Waher.Security.WAF.Model;
 
namespace Waher.Security.WAF
{
    public class WebApplicationFirewall : IWebApplicationFirewall, IDisposable
    {
        public const string Namespace = "http://waher.se/Schema/WAF.xsd";
 
        private static readonly XmlSchema schema = XSL.LoadSchema(typeof(WebApplicationFirewall).Namespace + ".Schema.WAF.xsd");
 
        private readonly Cache<string, object> internalCache;
        private readonly ILoginAuditor loginAuditor;
        private readonly string fileName;
        private readonly string appDataFolder;
        private Dictionary<string, WafAction> actionsById = new Dictionary<string, WafAction>();
        private Dictionary<int, RedirectionInfo> redirections = new Dictionary<int, RedirectionInfo>();
        private LinkedList<RedirectionInfo> pendingRedirections = new LinkedList<RedirectionInfo>();
        private Root root;
        private int redirectionCounter = 0;
 
        public WebApplicationFirewall(string Xml, string FileName, ILoginAuditor LoginAuditor,
            string AppDataFolder)
            : this(XML.ParseXml(Xml, true), FileName, LoginAuditor, AppDataFolder)
        {
        }
 
        public WebApplicationFirewall(XmlDocument Xml, string FileName, ILoginAuditor LoginAuditor,
            string AppDataFolder)
            : this(Xml.DocumentElement, FileName, LoginAuditor, AppDataFolder)
        {
        }
 
        public WebApplicationFirewall(XmlElement Xml, string FileName, ILoginAuditor LoginAuditor,
            string AppDataFolder)
        {
            this.fileName = FileName;
            this.appDataFolder = AppDataFolder;
            this.loginAuditor = LoginAuditor;
            this.root = WafAction.Parse(Xml, null, this) as Root;
 
            if (this.root is null)
                throw new Exception("Invalid root element of WAF definition.");
 
            this.internalCache = new Cache<string, object>(int.MaxValue,
                TimeSpan.FromDays(1), TimeSpan.FromDays(1))
            {
                MaxTimerIntervalMs = 1000
            };
 
            this.root.Prepare();
        }
 
        public static WebApplicationFirewall LoadFromFile(string FileName, ILoginAuditor LoginAuditor,
            string AppDataFolder)
        {
            XmlDocument Doc = XML.LoadFromFile(FileName, true);
            XSL.Validate(FileName, Doc, nameof(Root), Namespace, schema);
            return new WebApplicationFirewall(Doc, FileName, LoginAuditor, AppDataFolder);
        }
 
        public string FileName => this.fileName;
 
        public string AppDataFolder => this.appDataFolder;
 
        public ILoginAuditor LoginAuditor => this.loginAuditor;
 
        internal void RegisterAction(WafAction Action)
        {
            if (!string.IsNullOrEmpty(Action.Id))
                this.actionsById[Action.Id] = Action;
        }
 
        internal Cache<string, object> Cache => this.internalCache;
 
        public void Dispose()
        {
            this.internalCache.Dispose();
        }
 
        public bool TryGetActionById(string Id, [NotNullWhen(true)] out WafAction Action)
        {
            return this.actionsById.TryGetValue(Id, out Action);
        }
 
        public async Task<WafResult> Review(HttpRequest Request, HttpResource Resource)
        {
            try
            {
                ProcessingState State = new ProcessingState(Request, Resource, this);
 
                return await this.root.Review(State) ?? this.root.DefaultResult;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return this.root.DefaultResult;
            }
        }
 
        public Task Reload()
        {
            XmlDocument Doc = XML.LoadFromFile(this.fileName, true);
            XSL.Validate(this.fileName, Doc, nameof(Root), Namespace, schema);
 
            Dictionary<string, WafAction> Bak = this.actionsById; ;
            this.actionsById = new Dictionary<string, WafAction>();
 
            if (!(WafAction.Parse(Doc.DocumentElement, null, this) is Root Root2))
            {
                this.actionsById = Bak;
                throw new Exception("Invalid root element of WAF definition.");
            }
 
            this.root = Root2;
            this.root.Prepare();
 
            this.internalCache.Clear();
 
            return Task.CompletedTask;
        }
 
        internal WafResult GetRedirectionResult(RedirectionType Type, string Location)
        {
            DateTime Limit = DateTime.UtcNow.AddMinutes(-1);
 
            lock (this.redirections)
            {
                RedirectionInfo Info;
 
                while (!(this.pendingRedirections.First is null) &&
                    (Info = this.pendingRedirections.First.Value).Created <= Limit)
                {
                    this.redirections.Remove(Info.Index);
                    this.pendingRedirections.RemoveFirst();
                }
 
                int Index = --this.redirectionCounter;
                if (Index > 0)
                    Index = this.redirectionCounter = -1;
 
                Info = new RedirectionInfo(Type, Location, Index);
                this.redirections[Index] = Info;
                Info.Node = this.pendingRedirections.AddLast(Info);
 
                return (WafResult)Index;
            }
        }
 
        public bool TryGetRedirection(WafResult Result, out HttpException Redirection)
        {
            lock (this.redirections)
            {
                if (!this.redirections.TryGetValue((int)Result, out RedirectionInfo Info))
                {
                    Redirection = null;
                    return false;
                }
 
                this.redirections.Remove((int)Result);
                this.pendingRedirections.Remove(Info.Node);
 
                switch (Info.Type)
                {
                    case RedirectionType.TemporaryRedirection:
                    default:
                        Redirection = new TemporaryRedirectException(Info.Location);
                        break;
 
                    case RedirectionType.PermanentRedirection:
                        Redirection = new PermanentRedirectException(Info.Location);
                        break;
 
                    case RedirectionType.SeeOther:
                        Redirection = new SeeOtherException(Info.Location);
                        break;
                }
 
                return true;
            }
        }
    }
}