PreviewAuthenticator.cs

using Paiwise;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using System.Xml;
using Waher.Events;
using Waher.Networking.XMPP.Contracts.EventArguments;
using Waher.Runtime.Collections;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
using Waher.Service.IoTBroker.Legal.Attachments;
 
namespace Waher.Service.IoTBroker.Legal.Identity.Previews
{
    public class PreviewAuthenticator : IIdentityAuthenticatorService
    {
        public PreviewAuthenticator()
        {
        }
 
        public Task Start()
        {
            return Task.CompletedTask;
        }
 
        public Task Stop()
        {
            return Task.CompletedTask;
        }
 
        public Grade Supports(IIdentityApplication Application)
        {
            foreach (KeyValuePair<string, object> Claim in Application.Claims)
            {
                if (Claim.Key == PersonalInformation.PreviewTag)
                {
                    if (!(Claim.Value is string s) || string.IsNullOrEmpty(s))
                        return Grade.NotAtAll;
 
                    if (!Guid.TryParse(s, out _))
                        return Grade.NotAtAll;
 
                    try
                    {
                        string FileName = LegalComponent.GetPreviewFileName(s, ".id");
                        return File.Exists(FileName) ? Grade.Perfect : Grade.NotAtAll;
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                        return Grade.NotAtAll;
                    }
                }
            }
 
            return Grade.NotAtAll;
        }
 
        public async Task Validate(IIdentityApplication Application)
        {
            try
            {
                ChunkedList<string> PreviewFileNames = new ChunkedList<string>();
                string PreviewId = null;
 
                foreach (KeyValuePair<string, object> Claim in Application.Claims)
                {
                    if (Claim.Key != PersonalInformation.PreviewTag)
                        continue;
 
                    if (!(Claim.Value is string s) ||
                        string.IsNullOrEmpty(s) ||
                        !Guid.TryParse(s, out _))
                    {
                        Application.ReportError("Invalid preview identifier.", "en", string.Empty,
                            ValidationErrorType.Client, this);
                        return;
                    }
 
                    PreviewId = s;
                    break;
                }
 
                KeyValuePair<LegalIdentity, bool> P = await LegalComponent.GetLocalLegalIdentity(PreviewId, true);
                Dictionary<string, string> PotentialClaims = new Dictionary<string, string>();
                LegalIdentity Identity = P.Key;
                bool Preview = P.Value;
                byte[] Salt;
 
                if (!Preview || Identity is null)
                {
                    Application.ClaimInvalid(PersonalInformation.PreviewTag, "Invalid preview reference.", "en",
                        string.Empty, this);
                    return;
                }
 
                PreviewFileNames.Add(LegalComponent.GetPreviewFileName(Identity.Id, ".id"));
 
                foreach (AttachmentReference Ref in Identity.Attachments)
                {
                    PreviewFileNames.Add(LegalComponent.GetPreviewFileName(Ref.Id, ".att"));
 
                    if (Ref.FileName == "ApplicationReview.xml")
                    {
                        try
                        {
                            byte[] Bin = await LegalComponent.GetPreviewAttachment(Ref);
                            using MemoryStream ms = new MemoryStream(Bin);
                            XmlDocument Doc = new XmlDocument();
                            Doc.Load(ms);
 
                            if (Doc.DocumentElement.LocalName != "identityReview" ||
                                !LegalComponent.IsNamespaceLegalIdentity(Doc.DocumentElement.NamespaceURI))
                            {
                                continue;
                            }
 
                            // Note: Clients cannot freely add identityReview attachments.
 
                            IdentityReviewEventArgs e = new IdentityReviewEventArgs(null, Identity.Id);
                            Networking.XMPP.Contracts.ContractsClient.ParseValidationDetails(
                                Doc.DocumentElement, e);
 
                            if (e.HasPotentialClaims)
                            {
                                foreach (Networking.XMPP.Contracts.PotentialClaim Claim in 
                                    e.PotentialClaims)
                                {
                                    PotentialClaims[Claim.Claim] = Claim.Value;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                            continue;
                        }
                    }
                }
 
                Application.ClaimValid(PersonalInformation.PreviewTag, this);
 
                foreach (KeyValuePair<string, object> Claim in Application.Claims)
                {
                    switch (Claim.Key)
                    {
                        case PersonalInformation.PreviewTag:
                        case "ID":
                        case "State":
                        case "Created":
                        case "Updated":
                        case "From":
                        case "To":
                            continue;
                    }
 
                    string ClaimValue = Claim.Value?.ToString() ?? string.Empty;
                    string Value = Identity[Claim.Key];
 
                    if (string.IsNullOrEmpty(Value))
                    {
                        if (!PotentialClaims.TryGetValue(Claim.Key, out Value))
                            continue;
                    }
 
                    if (Value == ClaimValue)
                        Application.ClaimValid(Claim.Key, this);
                    else
                    {
                        Application.ClaimInvalid(Claim.Key,
                            "Does not match previewed value.", "en", "PreviewMismatch",
                            this);
                    }
                }
 
                foreach (IPhoto Photo in Application.Photos)
                {
                    foreach (AttachmentReference Ref in Identity.Attachments)
                    {
                        if (Photo.FileName != Ref.FileName)
                            continue;
 
                        string AttachmentFileName = LegalComponent.GetPreviewFileName(Ref.Id, ".att");
 
                        if (!File.Exists(AttachmentFileName))
                        {
                            Application.PhotoInvalid(Photo,
                                "Previewed attachment not found.", "en", "PreviewMismatch",
                                this);
                        }
                        else
                        {
                            KeyValuePair<byte[], string> P2 = await LegalComponent.GetPreviewSalt(AttachmentFileName);
                            Salt = P2.Key;
 
                            byte[] Blob = await XmppServerModule.LoadEncryptedFile(AttachmentFileName, Salt);
                            using MemoryStream ms = new MemoryStream(Blob);
                            using Stream Decoded = await XmppServerModule.DecodeBlob(ms);
                            byte[] Data = await Decoded.ReadAllAsync();
 
                            if (Data.Length == Photo.Binary.Length &&
                                Convert.ToBase64String(Data) == Convert.ToBase64String(Photo.Binary))
                            {
                                Application.PhotoValid(Photo, this);
                            }
                            else
                            {
                                Application.PhotoInvalid(Photo,
                                    "Does not match previewed photo.", "en", "PreviewMismatch",
                                    this);
                            }
                        }
 
                        break;
                    }
                }
 
                if (Application.IsValid.HasValue &&
                    Application.IsValid.Value &&
                    PreviewFileNames.HasFirstItem)
                {
                    foreach (string FileName in PreviewFileNames)
                    {
                        try
                        {
                            if (File.Exists(FileName))
                                File.Delete(FileName);
 
                            await LegalComponent.RemovePreviewSalt(FileName);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex, FileName);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Application.ReportError(ex.Message, string.Empty, string.Empty,
                    ValidationErrorType.Service, this);
            }
        }
    }
}