MultiFactorAuthentication.cs

using Paiwise;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP;
using Waher.Service.IoTBroker.WebServices;
 
namespace Waher.Service.IoTBroker.Legal.MFA
{
    public class MultiFactorAuthentication : HttpAsynchronousResource, IHttpGetMethod, IHttpPostMethod
    {
        public MultiFactorAuthentication()
            : base("/MFA")
        {
        }
 
        public override bool HandlesSubPaths => false;
 
        public override bool UserSessions => false;
 
        public bool AllowsPOST => true;
 
        public bool AllowsGET => true;
 
        public Task GET(HttpRequest Request, HttpResponse Response)
        {
            return Response.SendResponse(new TemporaryRedirectException("/MFATestForm.md"));
        }
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException("No data provided in post."));
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            string PNr;
            string Country;
            string TimeoutStr;
            string Reason;
            string LegalId;
            string SignatureStr;
            byte[] Signature = null;
            int Timeout = 0;
            bool HasTimeout = false;
 
            if (Content.HasError)
            {
                await Response.SendResponse(Content.Error);
                return;
            }
 
            if (Content.Decoded is XmlDocument Xml)
            {
                PNr = Xml.DocumentElement[PersonalInformation.PersonalNumberTag]?.InnerText;
                Country = Xml.DocumentElement[PersonalInformation.CountryTag]?.InnerText;
                TimeoutStr = Xml.DocumentElement["Timeout"]?.InnerText;
                Reason = Xml.DocumentElement["Reason"]?.InnerText;
                LegalId = Xml.DocumentElement["LegalId"]?.InnerText;
                SignatureStr = Xml.DocumentElement["Signature"]?.InnerText;
            }
            else if (Content.Decoded is Dictionary<string, object> Json)
            {
                if (Json.TryGetValue(PersonalInformation.PersonalNumberTag, out object v))
                    PNr = v.ToString();
                else
                    PNr = null;
 
                if (Json.TryGetValue(PersonalInformation.CountryTag, out v))
                    Country = v.ToString();
                else
                    Country = null;
 
                if (Json.TryGetValue("Timeout", out v))
                {
                    if (v is int i)
                    {
                        Timeout = i;
                        HasTimeout = true;
                        TimeoutStr = null;
                    }
                    else if (v is string s)
                        TimeoutStr = s;
                    else
                        TimeoutStr = v.ToString();
                }
                else
                    TimeoutStr = null;
 
                if (Json.TryGetValue("Reason", out v))
                    Reason = v.ToString();
                else
                    Reason = null;
 
                if (Json.TryGetValue("LegalId", out v))
                    LegalId = v.ToString();
                else
                    LegalId = null;
 
                if (Json.TryGetValue("Signature", out v))
                {
                    if (v is byte[] Bin)
                    {
                        Signature = Bin;
                        SignatureStr = null;
                    }
                    else
                        SignatureStr = v.ToString();
                }
                else
                    SignatureStr = null;
            }
            else if (Content.Decoded is Dictionary<string, string> Form)
            {
                if (!Form.TryGetValue(PersonalInformation.PersonalNumberTag, out PNr))
                    PNr = null;
 
                if (!Form.TryGetValue(PersonalInformation.CountryTag, out Country))
                    Country = null;
 
                if (!Form.TryGetValue("Timeout", out TimeoutStr))
                    TimeoutStr = null;
 
                if (!Form.TryGetValue("Reason", out Reason))
                    Reason = null;
 
                if (!Form.TryGetValue("LegalId", out LegalId))
                    LegalId = null;
 
                if (!Form.TryGetValue("Signature", out SignatureStr))
                    SignatureStr = null;
 
                if (Form.TryGetValue("g-recaptcha-response", out string RecaptchaResponse))
                {
                    if (!await Feedback.SiteVerify(RecaptchaResponse, Request.RemoteEndPoint))
                    {
                        await Response.SendResponse(new ForbiddenException(Request, "Request not properly verified. Bot?"));
                        return;
                    }
                }
                else if (string.IsNullOrEmpty(LegalId))
                {
                    await Response.SendResponse(new ForbiddenException(Request, "Request not properly verified. Bot?"));
                    return;
                }
            }
            else
            {
                await Response.SendResponse(new UnsupportedMediaTypeException("Unsupported Request Content-Type encoding used."));
                return;
            }
 
            if (string.IsNullOrEmpty(PNr))
            {
                await Response.SendResponse(new BadRequestException("Invalid PNR."));
                return;
            }
 
            if (string.IsNullOrEmpty(Country))
            {
                await Response.SendResponse(new BadRequestException("Invalid COUNTRY."));
                return;
            }
 
            if (string.IsNullOrEmpty(Reason))
            {
                await Response.SendResponse(new BadRequestException("Invalid Reason."));
                return;
            }
 
            if (!HasTimeout)
            {
                if (TimeoutStr is null || !int.TryParse(TimeoutStr, out Timeout))
                {
                    await Response.SendResponse(new BadRequestException("Invalid timeout."));
                    return;
                }
            }
 
            if (Timeout <= 0 || Timeout > 300)
            {
                await Response.SendResponse(new BadRequestException("Invalid timeout."));
                return;
            }
 
            if (string.IsNullOrEmpty(LegalId))
            {
                if (!(Signature is null) || !string.IsNullOrEmpty(SignatureStr))
                {
                    await Response.SendResponse(new BadRequestException("Missing legal identity."));
                    return;
                }
 
                DateTime? Next = await Gateway.LoginAuditor.GetEarliestLoginOpportunity(Request.RemoteEndPoint, "HTTP");
 
                if (Next.HasValue)
                {
                    StringBuilder sb = new StringBuilder();
                    DateTime TP = Next.Value;
                    DateTime Today = DateTime.Today;
 
                    if (Next.Value == DateTime.MaxValue)
                    {
                        sb.Append("This endpoint (");
                        sb.Append(Request.RemoteEndPoint);
                        sb.Append(") has been blocked from the system.");
                    }
                    else
                    {
                        sb.Append("Too many failed login attempts in a row registered. Try again after ");
                        sb.Append(TP.ToLongTimeString());
 
                        if (TP.Date != Today)
                        {
                            if (TP.Date == Today.AddDays(1))
                                sb.Append(" tomorrow");
                            else
                            {
                                sb.Append(", ");
                                sb.Append(TP.ToShortDateString());
                            }
                        }
 
                        sb.Append(". Remote Endpoint: ");
                        sb.Append(Request.RemoteEndPoint);
                    }
 
                    await Response.SendResponse(new TooManyRequestsException(sb.ToString()));
                    return;
                }
            }
            else
            {
                if (!XmppClient.BareJidRegEx.IsMatch(LegalId))
                {
                    await Response.SendResponse(new BadRequestException("Invalid Legal ID reference."));
                    return;
                }
 
                if (Signature is null && !string.IsNullOrEmpty(LegalId))
                {
                    if (string.IsNullOrEmpty(SignatureStr))
                    {
                        await Response.SendResponse(new BadRequestException("Missing signature."));
                        return;
                    }
 
                    try
                    {
                        Signature = Convert.FromBase64String(SignatureStr);
                    }
                    catch (Exception)
                    {
                        await Response.SendResponse(new BadRequestException("Invalid signature."));
                        return;
                    }
                }
            }
 
            this.ProcessRequest(Request, Response, PNr, Country, Timeout, Reason, LegalId, Signature);
        }
 
        private async void ProcessRequest(HttpRequest Request, HttpResponse Response,
            string PNr, string Country, int Timeout, string Reason, string LegalId, 
            byte[] Signature)
        {
            try
            {
                // TODO
            }
            catch (Exception ex)
            {
                await Response.SendResponse(ex);
            }
        }
 
    }
}