EndpointSecurity.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.XMPP.Events;
using Waher.Networking.XMPP.P2P.E2E;
using Waher.Networking.XMPP.P2P.SymmetricCiphers;
using Waher.Networking.XMPP.StanzaErrors;
using Waher.Runtime.Inventory;
using Waher.Runtime.Profiling;
 
namespace Waher.Networking.XMPP.P2P
{
    public class EndpointSecurity : IEndToEndEncryption
    {
        public const string IoTHarmonizationE2EIeeeV1 = "urn:ieee:iot:e2e:1.0";
 
        public const string IoTHarmonizationE2ENeuroFoundationV1 = "urn:nf:iot:e2e:1.0";
 
        public const string IoTHarmonizationE2ECurrent = IoTHarmonizationE2ENeuroFoundationV1;
 
        public static readonly string[] NamespacesIoTHarmonizationE2E = new string[]
        {
            IoTHarmonizationE2ENeuroFoundationV1,
            IoTHarmonizationE2EIeeeV1
        };
 
        public const string IoTHarmonizationP2PIeeeV1 = "urn:ieee:iot:p2p:1.0";
 
        public const string IoTHarmonizationP2PNeuroFoundationV1 = "urn:nf:iot:p2p:1.0";
 
        public const string IoTHarmonizationP2PCurrent = IoTHarmonizationP2PNeuroFoundationV1;
 
        public static readonly string[] NamespacesIoTHarmonizationP2P = new string[]
        {
            IoTHarmonizationP2PNeuroFoundationV1,
            IoTHarmonizationP2PIeeeV1
        };
 
        private static Dictionary<string, IE2eEndpoint> endpointTypes = new Dictionary<string, IE2eEndpoint>();
        private static bool initialized = false;
        private static Type[] e2eTypes = null;
        private static bool e2eTypesLocked = false;
 
        private readonly Dictionary<string, IE2eEndpoint[]> contacts;
        private XmppClient client;
        private readonly XmppServerlessMessaging serverlessMessaging;
        private IE2eEndpoint[] oldKeys = null;
        private IE2eEndpoint[] keys = null;
        private readonly UTF8Encoding encoding = new UTF8Encoding(false, false);
        private readonly object synchObject = new object();
        private readonly int securityStrength;
        private readonly bool ephemeralKeys;
        private Aes256 aes = new Aes256();
        private AeadChaCha20Poly1305 acp = new AeadChaCha20Poly1305();
        private ChaCha20 cha = new ChaCha20();
 
        public EndpointSecurity(XmppClient Client, int SecurityStrength)
            : this(Client, null, SecurityStrength)
        {
        }
 
        public EndpointSecurity(XmppClient Client, XmppServerlessMessaging ServerlessMessaging, int SecurityStrength)
            : this(Client, ServerlessMessaging, SecurityStrength, null)
        {
        }
 
        public EndpointSecurity(XmppClient Client, int SecurityStrength, params IE2eEndpoint[] LocalEndpoints)
            : this(Client, null, SecurityStrength, LocalEndpoints)
        {
        }
 
        public EndpointSecurity(XmppClient Client, XmppServerlessMessaging ServerlessMessaging, int SecurityStrength,
            params IE2eEndpoint[] LocalEndpoints)
            : base()
        {
            this.securityStrength = SecurityStrength;
            this.client = Client;
            this.serverlessMessaging = ServerlessMessaging;
            this.contacts = new Dictionary<string, IE2eEndpoint[]>(StringComparer.CurrentCultureIgnoreCase);
 
            if (!(LocalEndpoints is null))
            {
                this.keys = LocalEndpoints;
                this.ephemeralKeys = false;
            }
            else
            {
                this.keys = CreateEndpoints(SecurityStrength, 0, int.MaxValue);
                this.ephemeralKeys = true;
            }
 
            if (!(this.client is null))
            {
                this.RegisterHandlers(this.client);
 
                this.client.OnStateChanged += this.Client_OnStateChanged;
                this.client.OnPresence += this.Client_OnPresence;
                this.client.CustomPresenceXml += this.Client_CustomPresenceXml;
            }
        }
 
        private Task Client_CustomPresenceXml(object Sender, CustomPresenceEventArgs e)
        {
            this.AppendE2eInfo(e.Stanza);
            this.serverlessMessaging?.AppendP2pInfo(e.Stanza);
 
            return Task.CompletedTask;
        }
 
        public static IE2eEndpoint[] CreateEndpoints(int DesiredSecurityStrength, int MinSecurityStrength, int MaxSecurityStrength)
        {
            return CreateEndpoints(DesiredSecurityStrength, MinSecurityStrength, MaxSecurityStrength, null);
        }
 
        public static IE2eEndpoint[] CreateEndpoints(int DesiredSecurityStrength, int MinSecurityStrength, int MaxSecurityStrength,
            Type OnlyIfDerivedFrom)
        {
            return CreateEndpoints(DesiredSecurityStrength, MinSecurityStrength, MaxSecurityStrength, OnlyIfDerivedFrom, null);
        }
 
        public static IE2eEndpoint[] CreateEndpoints(int DesiredSecurityStrength, int MinSecurityStrength, int MaxSecurityStrength,
            Type OnlyIfDerivedFrom, ProfilerThread Thread)
        {
            Thread = Thread?.CreateSubThread("Endpoints", ProfilerThreadType.Sequential);
            try
            {
                Thread?.Start();
                Thread?.NewState("Init");
 
                List<IE2eEndpoint> Result = new List<IE2eEndpoint>();
                TypeInfo OnlyIfDerivedFromType = OnlyIfDerivedFrom?.GetTypeInfo();
                IEnumerable<IE2eEndpoint> Templates;
                bool CheckHeritance = true;
 
                lock (endpointTypes)
                {
                    if (initialized)
                        Templates = endpointTypes.Values;
                    else
                    {
                        Dictionary<string, IE2eEndpoint> E2eTypes = new Dictionary<string, IE2eEndpoint>();
                        Dictionary<string, bool> TypeNames = new Dictionary<string, bool>();
                        TypeInfo E2eTypeInfo = typeof(IE2eEndpoint).GetTypeInfo();
 
                        foreach (KeyValuePair<string, IE2eEndpoint> P in endpointTypes)
                        {
                            E2eTypes[P.Key] = P.Value;
                            TypeNames[P.Value.GetType().FullName] = true;
                        }
 
                        foreach (Type T in e2eTypes ?? Types.GetTypesImplementingInterface(typeof(IE2eEndpoint)))
                        {
                            if (TypeNames.ContainsKey(T.FullName))
                                continue;
 
                            TypeInfo TI = T.GetTypeInfo();
                            if (!(e2eTypes is null) && !E2eTypeInfo.IsAssignableFrom(TI))
                                continue;
 
                            if (!(OnlyIfDerivedFromType?.IsAssignableFrom(TI) ?? true))
                                continue;
 
                            ConstructorInfo CI = Types.GetDefaultConstructor(T);
                            if (CI is null)
                                continue;
 
                            try
                            {
                                IE2eEndpoint Endpoint = (IE2eEndpoint)CI.Invoke(Types.NoParameters);
                                E2eTypes[Endpoint.Namespace + "#" + Endpoint.LocalName] = Endpoint;
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex);
                                continue;
                            }
                        }
 
                        endpointTypes = E2eTypes;
                        Templates = E2eTypes.Values;
 
                        if (OnlyIfDerivedFromType is null)
                            initialized = true;
                        else
                            CheckHeritance = false;
                    }
                }
 
                foreach (IE2eEndpoint Endpoint in Templates)
                {
                    if (CheckHeritance && !(OnlyIfDerivedFromType?.IsAssignableFrom(Endpoint.GetType().GetTypeInfo()) ?? true))
                        continue;
 
                    Thread?.NewState(Endpoint.LocalName);
 
                    IE2eEndpoint Endpoint2 = Endpoint.Create(DesiredSecurityStrength);
                    int i = Endpoint2.SecurityStrength;
                    if (i >= MinSecurityStrength && i <= MaxSecurityStrength)
                        Result.Add(Endpoint2);
                    else
                        Endpoint2.Dispose();
                }
 
                return Result.ToArray();
            }
            finally
            {
                Thread?.Stop();
            }
        }
 
        public static void SetCiphers(Type[] CipherTypes, bool Lock)
        {
            if (e2eTypesLocked)
                throw new InvalidOperationException("Ciphers locked.");
 
            e2eTypes = CipherTypes;
            e2eTypesLocked = Lock;
        }
 
        public static bool TryGetEndpoint(string LocalName, string Namespace, out IE2eEndpoint Endpoint)
        {
            if (Namespace.StartsWith("urn:ieee:"))
                Namespace = Namespace.Replace("urn:ieee:", "urn:nf:");
 
            string Key = Namespace + "#" + LocalName;
 
            if (endpointTypes.TryGetValue(Key, out Endpoint))
                return true;
            else if (initialized || endpointTypes.Count > 0)
                return false;
 
            CreateEndpoints(128, 0, int.MaxValue);
 
            return endpointTypes.TryGetValue(Key, out Endpoint);
        }
 
        public static bool TryCreateEndpoint(string LocalName, string Namespace, out IE2eEndpoint Endpoint)
        {
            if (TryGetEndpoint(LocalName, Namespace, out Endpoint))
            {
                Endpoint = Endpoint.Create(Endpoint.SecurityStrength);
                return true;
            }
            else
                return false;
        }
 
        public virtual void Dispose()
        {
            if (!(this.client is null))
            {
                this.client.OnStateChanged -= this.Client_OnStateChanged;
                this.client.OnPresence -= this.Client_OnPresence;
                this.client.CustomPresenceXml -= this.Client_CustomPresenceXml;
 
                this.UnregisterHandlers(this.client);
                this.client = null;
            }
 
            if (!(this.oldKeys is null))
            {
                foreach (IE2eEndpoint E2e in this.oldKeys)
                    E2e.Dispose();
            }
 
            if (!(this.keys is null))
            {
                foreach (IE2eEndpoint E2e in this.keys)
                    E2e.Dispose();
 
            }
 
            lock (this.contacts)
            {
                foreach (IE2eEndpoint[] Endpoints in this.contacts.Values)
                {
                    foreach (IE2eEndpoint Endpoint in Endpoints)
                        Endpoint.Dispose();
                }
 
                this.contacts.Clear();
            }
 
            this.aes?.Dispose();
            this.aes = null;
 
            this.acp?.Dispose();
            this.acp = null;
 
            this.cha?.Dispose();
            this.cha = null;
        }
 
        private Task Client_OnStateChanged(object Sender, XmppState NewState)
        {
            if (NewState == XmppState.RequestingSession && this.ephemeralKeys)
                this.GenerateNewKey();
 
            return Task.CompletedTask;
        }
 
        public void GenerateNewKey()
        {
            lock (this.synchObject)
            {
                IE2eEndpoint[] Keys = this.oldKeys;
 
                this.oldKeys = this.keys;
 
                if (!(Keys is null))
                {
                    foreach (IE2eEndpoint E2e in Keys)
                        E2e.Dispose();
                }
 
                int i, c = this.keys.Length;
                Keys = new IE2eEndpoint[c];
 
                for (i = 0; i < c; i++)
                {
                    Keys[i] = this.keys[i].Create(this.securityStrength);
                    Keys[i].Previous = this.keys[i];
                    this.keys[i].Previous = null;
                }
 
                this.keys = Keys;
            }
        }
 
        public virtual void RegisterHandlers(XmppClient Client)
        {
            #region Neuro-Foundation V1
 
            Client?.RegisterMessageHandler("aes", IoTHarmonizationE2ENeuroFoundationV1, this.AesMessageHandler, false);
            Client?.RegisterIqGetHandler("aes", IoTHarmonizationE2ENeuroFoundationV1, this.AesIqGetHandler, false);
            Client?.RegisterIqSetHandler("aes", IoTHarmonizationE2ENeuroFoundationV1, this.AesIqSetHandler, false);
            Client?.RegisterMessageHandler("acp", IoTHarmonizationE2ENeuroFoundationV1, this.AcpMessageHandler, false);
            Client?.RegisterIqGetHandler("acp", IoTHarmonizationE2ENeuroFoundationV1, this.AcpIqGetHandler, false);
            Client?.RegisterIqSetHandler("acp", IoTHarmonizationE2ENeuroFoundationV1, this.AcpIqSetHandler, false);
            Client?.RegisterMessageHandler("cha", IoTHarmonizationE2ENeuroFoundationV1, this.ChaMessageHandler, false);
            Client?.RegisterIqGetHandler("cha", IoTHarmonizationE2ENeuroFoundationV1, this.ChaIqGetHandler, false);
            Client?.RegisterIqSetHandler("cha", IoTHarmonizationE2ENeuroFoundationV1, this.ChaIqSetHandler, false);
            Client?.RegisterIqSetHandler("synchE2e", IoTHarmonizationE2ENeuroFoundationV1, this.SynchE2eHandler, false);
 
            #endregion
 
            #region IEEE v1
 
            Client?.RegisterMessageHandler("aes", IoTHarmonizationE2EIeeeV1, this.AesMessageHandler, false);
            Client?.RegisterIqGetHandler("aes", IoTHarmonizationE2EIeeeV1, this.AesIqGetHandler, false);
            Client?.RegisterIqSetHandler("aes", IoTHarmonizationE2EIeeeV1, this.AesIqSetHandler, false);
            Client?.RegisterMessageHandler("acp", IoTHarmonizationE2EIeeeV1, this.AcpMessageHandler, false);
            Client?.RegisterIqGetHandler("acp", IoTHarmonizationE2EIeeeV1, this.AcpIqGetHandler, false);
            Client?.RegisterIqSetHandler("acp", IoTHarmonizationE2EIeeeV1, this.AcpIqSetHandler, false);
            Client?.RegisterMessageHandler("cha", IoTHarmonizationE2EIeeeV1, this.ChaMessageHandler, false);
            Client?.RegisterIqGetHandler("cha", IoTHarmonizationE2EIeeeV1, this.ChaIqGetHandler, false);
            Client?.RegisterIqSetHandler("cha", IoTHarmonizationE2EIeeeV1, this.ChaIqSetHandler, false);
            Client?.RegisterIqSetHandler("synchE2e", IoTHarmonizationE2EIeeeV1, this.SynchE2eHandler, false);
 
            #endregion
        }
 
        public virtual void UnregisterHandlers(XmppClient Client)
        {
            #region Neuro-Foundation V1
 
            Client?.UnregisterMessageHandler("aes", IoTHarmonizationE2ENeuroFoundationV1, this.AesMessageHandler, false);
            Client?.UnregisterIqGetHandler("aes", IoTHarmonizationE2ENeuroFoundationV1, this.AesIqGetHandler, false);
            Client?.UnregisterIqSetHandler("aes", IoTHarmonizationE2ENeuroFoundationV1, this.AesIqSetHandler, false);
            Client?.UnregisterMessageHandler("acp", IoTHarmonizationE2ENeuroFoundationV1, this.AcpMessageHandler, false);
            Client?.UnregisterIqGetHandler("acp", IoTHarmonizationE2ENeuroFoundationV1, this.AcpIqGetHandler, false);
            Client?.UnregisterIqSetHandler("acp", IoTHarmonizationE2ENeuroFoundationV1, this.AcpIqSetHandler, false);
            Client?.UnregisterMessageHandler("cha", IoTHarmonizationE2ENeuroFoundationV1, this.ChaMessageHandler, false);
            Client?.UnregisterIqGetHandler("cha", IoTHarmonizationE2ENeuroFoundationV1, this.ChaIqGetHandler, false);
            Client?.UnregisterIqSetHandler("cha", IoTHarmonizationE2ENeuroFoundationV1, this.ChaIqSetHandler, false);
            Client?.UnregisterIqSetHandler("synchE2e", IoTHarmonizationE2ENeuroFoundationV1, this.SynchE2eHandler, false);
 
            #endregion
 
            #region IEEE v1
 
            Client?.UnregisterMessageHandler("aes", IoTHarmonizationE2EIeeeV1, this.AesMessageHandler, false);
            Client?.UnregisterIqGetHandler("aes", IoTHarmonizationE2EIeeeV1, this.AesIqGetHandler, false);
            Client?.UnregisterIqSetHandler("aes", IoTHarmonizationE2EIeeeV1, this.AesIqSetHandler, false);
            Client?.UnregisterMessageHandler("acp", IoTHarmonizationE2EIeeeV1, this.AcpMessageHandler, false);
            Client?.UnregisterIqGetHandler("acp", IoTHarmonizationE2EIeeeV1, this.AcpIqGetHandler, false);
            Client?.UnregisterIqSetHandler("acp", IoTHarmonizationE2EIeeeV1, this.AcpIqSetHandler, false);
            Client?.UnregisterMessageHandler("cha", IoTHarmonizationE2EIeeeV1, this.ChaMessageHandler, false);
            Client?.UnregisterIqGetHandler("cha", IoTHarmonizationE2EIeeeV1, this.ChaIqGetHandler, false);
            Client?.UnregisterIqSetHandler("cha", IoTHarmonizationE2EIeeeV1, this.ChaIqSetHandler, false);
            Client?.UnregisterIqSetHandler("synchE2e", IoTHarmonizationE2EIeeeV1, this.SynchE2eHandler, false);
 
            #endregion
        }
 
        public static List<IE2eEndpoint> ParseE2eKeys(XmlElement E2E)
        {
            List<IE2eEndpoint> Endpoints = null;
 
            foreach (XmlNode N in E2E.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    IE2eEndpoint Endpoint = ParseE2eKey(E);
 
                    if (!(Endpoint is null))
                    {
                        if (Endpoints is null)
                            Endpoints = new List<IE2eEndpoint>();
 
                        Endpoints.Add(Endpoint);
                    }
                }
            }
 
            return Endpoints;
        }
 
        public static IE2eEndpoint ParseE2eKey(XmlElement E)
        {
            if (TryGetEndpoint(E.LocalName, E.NamespaceURI, out IE2eEndpoint Endpoint))
                return Endpoint.Parse(E);
            else
                return null;
        }
 
        public bool AddPeerPkiInfo(string FullJID, XmlElement E2E)
        {
            try
            {
                List<IE2eEndpoint> Endpoints = null;
                IE2eEndpoint[] OldEndpoints = null;
                int i;
 
                if (!(E2E is null))
                    Endpoints = ParseE2eKeys(E2E);
 
                if (Endpoints is null)
                {
                    this.RemovePeerPkiInfo(FullJID);
                    return false;
                }
 
                Endpoints.Sort((e1, e2) =>
                {
                    int Diff = e2.SecurityStrength - e1.SecurityStrength;
                    if (Diff != 0)
                        return Diff;
 
                    return e1.Score - e2.Score;
                });
 
                i = 0;
                int j, c = Endpoints.Count;
 
                for (j = 1; j < c; j++)
                {
                    if (Endpoints[j].SecurityStrength >= this.securityStrength)
                        i = j;
                }
 
                if (i != 0)
                {
                    IE2eEndpoint Temp = Endpoints[i];
                    Endpoints.RemoveAt(i);
                    Endpoints.Insert(0, Temp);
                }
 
                lock (this.contacts)
                {
                    if (!this.contacts.TryGetValue(FullJID, out OldEndpoints))
                        OldEndpoints = null;
 
                    this.contacts[FullJID] = Endpoints.ToArray();
                }
 
                if (!(OldEndpoints is null))
                {
                    foreach (IE2eEndpoint Endpoint in OldEndpoints)
                        Endpoint.Dispose();
                }
 
                return true;
            }
            catch (Exception)
            {
                this.RemovePeerPkiInfo(FullJID);
                return false;
            }
        }
 
        public bool RemovePeerPkiInfo(string FullJID)
        {
            IE2eEndpoint[] List;
 
            lock (this.contacts)
            {
                if (!this.contacts.TryGetValue(FullJID, out List))
                    return false;
                else
                    this.contacts.Remove(FullJID);
            }
 
            foreach (IE2eEndpoint Endpoint in List)
                Endpoint.Dispose();
 
            return true;
        }
 
        public bool ContainsKey(string FullJid)
        {
            lock (this.contacts)
            {
                return this.contacts.ContainsKey(FullJid);
            }
        }
 
        public IE2eEndpoint[] GetE2eEndpoints(string FullJid)
        {
            lock (this.contacts)
            {
                if (this.contacts.TryGetValue(FullJid, out IE2eEndpoint[] Endpoints))
                    return Endpoints;
            }
 
            if (string.Compare(FullJid, this.client.BareJID) == 0)
            {
                StringBuilder Xml = new StringBuilder();
 
                this.AppendE2eInfo(Xml);
 
                XmlDocument Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
                Doc.LoadXml(Xml.ToString());
 
                return ParseE2eKeys(Doc.DocumentElement)?.ToArray() ?? new IE2eEndpoint[0];
            }
 
            return new E2eEndpoint[0];
        }
 
        public virtual Task<byte[]> Encrypt(string Id, string Type, string From, string To, byte[] Data, out IE2eEndpoint EndpointReference)
        {
            IE2eEndpoint RemoteEndpoint = this.FindRemoteEndpoint(To, null);
            if (RemoteEndpoint is null)
            {
                EndpointReference = null;
                return null;
            }
 
            EndpointReference = this.FindLocalEndpoint(RemoteEndpoint);
            if (EndpointReference is null)
                return null;
 
            uint Counter = EndpointReference.GetNextCounter();
            byte[] Encrypted = EndpointReference.DefaultSymmetricCipher.Encrypt(Id, Type, From, To, Counter, Data, EndpointReference, RemoteEndpoint);
 
            return Task.FromResult(Encrypted);
        }
 
        public virtual Task<byte[]> Decrypt(string EndpointReference, string Id, string Type, string From, string To, byte[] Data,
            IE2eSymmetricCipher SymmetricCipher)
        {
            IE2eEndpoint RemoteEndpoint = this.FindRemoteEndpoint(From, EndpointReference);
            if (RemoteEndpoint is null)
                return null;
 
            IE2eEndpoint LocalEndpoint = this.FindLocalEndpoint(RemoteEndpoint);
            if (LocalEndpoint is null)
                return null;
 
            IE2eSymmetricCipher Cipher = LocalEndpoint.DefaultSymmetricCipher;
            if (!(SymmetricCipher is null) && Cipher.GetType() != SymmetricCipher.GetType())
                Cipher = SymmetricCipher;
 
            byte[] Decrypted = Cipher.Decrypt(Id, Type, From, To, Data, RemoteEndpoint, LocalEndpoint);
 
            return Task.FromResult(Decrypted);
        }
 
        private IE2eEndpoint FindRemoteEndpoint(string RemoteJid, string EndpointReference)
        {
            IE2eEndpoint[] Endpoints;
 
            lock (this.contacts)
            {
                if (!this.contacts.TryGetValue(RemoteJid, out Endpoints))
                    return null;
            }
 
            if (EndpointReference is null)
                return Endpoints[0];
 
            string Namespace;
            string LocalName;
            int i;
 
            i = EndpointReference.IndexOf('#');
            if (i < 0)
            {
                LocalName = EndpointReference;
                Namespace = IoTHarmonizationE2ECurrent;
            }
            else
            {
                Namespace = EndpointReference.Substring(0, i).Replace("urn:ieee:", "urn:nf:");
                LocalName = EndpointReference.Substring(i + 1);
            }
 
            foreach (IE2eEndpoint Endpoint in Endpoints)
            {
                if (Endpoint.LocalName == LocalName && Endpoint.Namespace == Namespace)
                    return Endpoint;
            }
 
            return null;
        }
 
        public virtual async Task<IE2eEndpoint> Encrypt(string Id, string Type, string From, string To, Stream Data, Stream Encrypted)
        {
            IE2eEndpoint RemoteEndpoint = this.FindRemoteEndpoint(To, null);
            if (RemoteEndpoint is null)
                return null;
 
            IE2eEndpoint LocalEndpoint = this.FindLocalEndpoint(RemoteEndpoint);
            if (LocalEndpoint is null)
                return null;
 
            uint Counter = LocalEndpoint.GetNextCounter();
            await LocalEndpoint.DefaultSymmetricCipher.Encrypt(Id, Type, From, To, Counter, Data, Encrypted, LocalEndpoint, RemoteEndpoint);
 
            return LocalEndpoint;
        }
 
        public virtual async Task<Stream> Decrypt(string EndpointReference, string Id, string Type, string From, string To, Stream Data,
            IE2eSymmetricCipher SymmetricCipher)
        {
            IE2eEndpoint RemoteEndpoint = this.FindRemoteEndpoint(From, EndpointReference);
            if (RemoteEndpoint is null)
                return null;
 
            IE2eEndpoint LocalEndpoint = this.FindLocalEndpoint(RemoteEndpoint);
            if (LocalEndpoint is null)
                return null;
 
            IE2eSymmetricCipher Cipher = LocalEndpoint.DefaultSymmetricCipher;
            if (!(SymmetricCipher is null) && Cipher.GetType() != SymmetricCipher.GetType())
                Cipher = SymmetricCipher;
 
            return await Cipher.Decrypt(Id, Type, From, To, Data, RemoteEndpoint, LocalEndpoint);
        }
 
        public virtual async Task<bool> Encrypt(XmppClient Client, string Id, string Type, string From, string To, string DataXml, StringBuilder Xml)
        {
            bool SniffE2eInfo = Client.HasSniffers && Client.TryGetTag("ShowE2E", out object Obj) && Obj is bool b && b;
            IE2eEndpoint RemoteEndpoint = this.FindRemoteEndpoint(To, null);
            if (RemoteEndpoint is null)
            {
                if (SniffE2eInfo)
                    await Client.Warning("Remote E2E endpoint not found. Unable to encrypt message.");
 
                return false;
            }
 
            IE2eEndpoint LocalEndpoint = this.FindLocalEndpoint(RemoteEndpoint);
            if (LocalEndpoint is null)
            {
                if (SniffE2eInfo)
                    await Client.Warning("Local E2E endpoint matching remote endpoint not found. Unable to encrypt message.");
 
                return false;
            }
 
            byte[] Data = this.encoding.GetBytes(DataXml);
            uint Counter = LocalEndpoint.GetNextCounter();
            bool Result = LocalEndpoint.DefaultSymmetricCipher.Encrypt(Id, Type, From, To, Counter, Data, Xml, LocalEndpoint, RemoteEndpoint);
 
            if (SniffE2eInfo)
                await Client.Information(DataXml);
 
            return Result;
        }
 
        private IE2eEndpoint FindLocalEndpoint(IE2eEndpoint RemoteEndpoint)
        {
            IE2eEndpoint[] Endpoints = this.keys;
            int c = Endpoints.Length;
            int i;
            Type T = RemoteEndpoint.GetType();
 
            for (i = 0; i < c; i++)
            {
                if (Endpoints[i].GetType() == T)
                    return Endpoints[i];
            }
 
            return null;
        }
 
        public IE2eEndpoint FindLocalEndpoint(string KeyName)
        {
            return this.FindLocalEndpoint(KeyName, string.Empty);
        }
 
        public IE2eEndpoint FindLocalEndpoint(string KeyName, string KeyNamespace)
        {
            IE2eEndpoint[] Endpoints = this.keys;
            int c = Endpoints.Length;
            int i;
 
            for (i = 0; i < c; i++)
            {
                if (Endpoints[i].LocalName == KeyName &&
                    (Endpoints[i].Namespace == KeyNamespace || string.IsNullOrEmpty(KeyNamespace)))
                {
                    return Endpoints[i];
                }
            }
 
            return null;
        }
 
        public virtual async Task<Tuple<string, string>> Decrypt(XmppClient Client, string Id, string Type, string From, string To, XmlElement E2eElement,
            IE2eSymmetricCipher SymmetricCipher)
        {
            bool SniffE2eInfo = Client.HasSniffers && Client.TryGetTag("ShowE2E", out object Obj) && Obj is bool b && b;
            string EndpointReference = XML.Attribute(E2eElement, "r");
            IE2eEndpoint RemoteEndpoint = this.FindRemoteEndpoint(From, EndpointReference);
            if (RemoteEndpoint is null)
            {
                if (SniffE2eInfo)
                    await Client.Error("Remote E2E endpoint not found. Unable to decrypt message.");
 
                return null;
            }
 
            IE2eEndpoint LocalEndpoint = this.FindLocalEndpoint(RemoteEndpoint);
            if (LocalEndpoint is null)
            {
                if (SniffE2eInfo)
                    await Client.Error("Local E2E endpoint matching remote endpoint not found. Unable to decrypt message.");
                
                return null;
            }
 
            IE2eSymmetricCipher Cipher = LocalEndpoint.DefaultSymmetricCipher;
            if (!(SymmetricCipher is null) && Cipher.GetType() != SymmetricCipher.GetType())
                Cipher = SymmetricCipher;
 
            string Xml = Cipher.Decrypt(Id, Type, From, To, E2eElement, RemoteEndpoint, LocalEndpoint);
            if (Xml is null)
            {
                if (SniffE2eInfo)
                    await Client.Error("Unable to decrypt message.");
                
                return null;
            }
 
            if (SniffE2eInfo)
                await Client.Information(Xml);
 
            return new Tuple<string, string>(Xml, EndpointReference);
        }
 
        private Task AesMessageHandler(object Sender, MessageEventArgs e)
        {
            return this.E2eMessageHandler(Sender, e, this.aes);
        }
 
        private Task AcpMessageHandler(object Sender, MessageEventArgs e)
        {
            return this.E2eMessageHandler(Sender, e, this.acp);
        }
 
        private Task ChaMessageHandler(object Sender, MessageEventArgs e)
        {
            return this.E2eMessageHandler(Sender, e, this.cha);
        }
 
        private async Task E2eMessageHandler(object Sender, MessageEventArgs e, IE2eSymmetricCipher Cipher)
        {
            XmppClient Client = Sender as XmppClient;
            Tuple<string, string> T = await this.Decrypt(Client, e.Id, e.Message.GetAttribute("type"), e.From, e.To, e.Content, Cipher);
            if (T is null)
            {
                await Client.Error("Unable to decrypt or verify message.");
                return;
            }
 
            string Xml = T.Item1;
            string EndpointReference = T.Item2;
 
            XmlDocument Doc = new XmlDocument()
            {
                PreserveWhitespace = true
            };
            Doc.LoadXml(Xml);
 
            MessageEventArgs e2 = new MessageEventArgs(Client, Doc.DocumentElement)
            {
                From = e.From,
                To = e.To,
                Id = e.Id,
                E2eEncryption = this,
                E2eReference = EndpointReference
            };
 
            Client.ProcessMessage(e2);
        }
 
        public virtual bool TryGetSymmetricCipher(string LocalName, string Namespace, out IE2eSymmetricCipher Cipher)
        {
            switch (LocalName)
            {
                case "aes": Cipher = this.aes; return true;
                case "acp": Cipher = this.acp; return true;
                case "cha": Cipher = this.cha; return true;
            }
 
            Cipher = null;
            return false;
        }
 
        protected virtual async Task IqResult(object Sender, IqResultEventArgs e)
        {
            XmppClient Client = Sender as XmppClient;
            XmlElement E = e.FirstElement;
            object[] P = (object[])e.State;
            EventHandlerAsync<IqResultEventArgs> Callback = (EventHandlerAsync<IqResultEventArgs>)P[0];
            object State = P[1];
 
            if (!this.TryGetSymmetricCipher(E.LocalName, E.NamespaceURI, out IE2eSymmetricCipher Cipher))
                Cipher = null;
 
            if (!(Cipher is null))
            {
                Tuple<string, string> T = await this.Decrypt(Client, e.Id, e.Response.GetAttribute("type"), e.From, e.To, E, Cipher);
                if (T is null)
                {
                    await Client.Error("Unable to decrypt or verify response.");
                    return;
                }
 
                string Content = T.Item1;
                string EndpointReference = T.Item2;
                StringBuilder Xml = new StringBuilder();
 
                Xml.Append("<iq xmlns=\"jabber:client\" id=\"");
                Xml.Append(e.Id);
                Xml.Append("\" from=\"");
                Xml.Append(XML.Encode(e.From));
                Xml.Append("\" to=\"");
                Xml.Append(XML.Encode(e.To));
 
                if (e.Ok)
                    Xml.Append("\" type=\"result\">");
                else
                    Xml.Append("\" type=\"error\">");
 
                Xml.Append(Content);
                Xml.Append("</iq>");
 
                XmlDocument Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
                Doc.LoadXml(Xml.ToString());
 
                IqResultEventArgs e2 = new IqResultEventArgs(this, EndpointReference, Cipher,
                    Doc.DocumentElement, e.Id, e.To, e.From, e.Ok, State);
                await Callback.Raise(Sender, e2);
            }
            else if (!e.Ok && this.IsForbidden(e.ErrorElement))
            {
                E2ETransmission E2ETransmission = (E2ETransmission)P[2];
                string Id = (string)P[3];
                string To = (string)P[4];
                string Xml = (string)P[5];
                string Type = (string)P[6];
                int RetryTimeout = (int)P[7];
                int NrRetries = (int)P[8];
                bool DropOff = (bool)P[9];
                int MaxRetryTimeout = (int)P[10];
                bool PkiSynchronized = (bool)P[11];
 
                if (PkiSynchronized)
                {
                    e.State = State;
                    await Callback.Raise(Sender, e);
                }
                else
                {
                    await this.SynchronizeE2e(To, async (Sender2, e2) =>
                    {
                        if (e2.Ok)
                        {
                            await this.SendIq(Client, E2ETransmission, Id, To, Xml, Type, Callback, State,
                                RetryTimeout, NrRetries, DropOff, MaxRetryTimeout, true);
                        }
                        else
                        {
                            e.State = State;
                            await Callback.Raise(Sender, e);
                        }
                    });
                };
            }
            else
            {
                e.State = State;
                await Callback.Raise(Sender, e);
            }
        }
 
        private bool IsForbidden(XmlElement E)
        {
            if (E is null)
                return false;
 
            XmlElement E2;
 
            foreach (XmlNode N in E.ChildNodes)
            {
                E2 = N as XmlElement;
                if (E2 is null)
                    continue;
 
                if (E2.LocalName == "forbidden" && E2.NamespaceURI == XmppClient.NamespaceXmppStanzas)
                    return true;
            }
 
            return false;
        }
 
        private string EmbedIq(IqEventArgs e, string Type, string Content)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<iq xmlns=\"jabber:client\" id=\"");
            Xml.Append(e.Id);
            Xml.Append("\" from=\"");
            Xml.Append(XML.Encode(e.From));
            Xml.Append("\" to=\"");
            Xml.Append(XML.Encode(e.To));
            Xml.Append("\" type=\"");
            Xml.Append(Type);
            Xml.Append("\">");
            Xml.Append(Content);
            Xml.Append("</iq>");
 
            return Xml.ToString();
        }
 
        private Task AesIqGetHandler(object Sender, IqEventArgs e)
        {
            return this.E2eIqGetHandler(Sender, e, this.aes);
        }
 
        private Task AcpIqGetHandler(object Sender, IqEventArgs e)
        {
            return this.E2eIqGetHandler(Sender, e, this.acp);
        }
 
        private Task ChaIqGetHandler(object Sender, IqEventArgs e)
        {
            return this.E2eIqGetHandler(Sender, e, this.cha);
        }
 
        private async Task E2eIqGetHandler(object Sender, IqEventArgs e, IE2eSymmetricCipher Cipher)
        {
            XmppClient Client = Sender as XmppClient;
            Tuple<string, string> T = await this.Decrypt(Client, e.Id, e.IQ.GetAttribute("type"), e.From, e.To, e.Query, Cipher);
            if (T is null)
            {
                await Client.Error("Unable to decrypt or verify request.");
                await e.IqError(new ForbiddenException("Unable to decrypt or verify message.", e.IQ));
                return;
            }
 
            string Content = T.Item1;
            string EndpointReference = T.Item2;
 
            XmlDocument Doc = new XmlDocument()
            {
                PreserveWhitespace = true
            };
            Doc.LoadXml(this.EmbedIq(e, "get", Content));
 
            IqEventArgs e2 = new IqEventArgs(Client, this, EndpointReference, Cipher, Doc.DocumentElement, e.Id, e.To, e.From);
            await Client.ProcessIqGet(e2);
        }
 
        private Task AesIqSetHandler(object Sender, IqEventArgs e)
        {
            return this.E2eIqSetHandler(Sender, e, this.aes);
        }
 
        private Task AcpIqSetHandler(object Sender, IqEventArgs e)
        {
            return this.E2eIqSetHandler(Sender, e, this.acp);
        }
 
        private Task ChaIqSetHandler(object Sender, IqEventArgs e)
        {
            return this.E2eIqSetHandler(Sender, e, this.cha);
        }
 
        private async Task E2eIqSetHandler(object Sender, IqEventArgs e, IE2eSymmetricCipher Cipher)
        {
            XmppClient Client = Sender as XmppClient;
            Tuple<string, string> T = await this.Decrypt(Client, e.Id, e.IQ.GetAttribute("type"), e.From, e.To, e.Query, Cipher);
            if (T is null)
            {
                await Client.Error("Unable to decrypt or verify request.");
                await e.IqError(new ForbiddenException("Unable to decrypt or verify message.", e.IQ));
                return;
            }
 
            string Content = T.Item1;
            string EndpointReference = T.Item2;
 
            XmlDocument Doc = new XmlDocument()
            {
                PreserveWhitespace = true
            };
            Doc.LoadXml(this.EmbedIq(e, "set", Content));
 
            IqEventArgs e2 = new IqEventArgs(Client, this, EndpointReference, Cipher, Doc.DocumentElement, e.Id, e.To, e.From);
            await Client.ProcessIqSet(e2);
        }
 
        public Task SendMessage(XmppClient Client, E2ETransmission E2ETransmission, QoSLevel QoS,
            MessageType Type, string Id, string To, string CustomXml, string Body, string Subject,
            string Language, string ThreadId, string ParentThreadId, EventHandlerAsync<DeliveryEventArgs> DeliveryCallback,
            object State)
        {
            return this.SendMessage(Client, E2ETransmission, QoS, Type, Id, To, CustomXml, Body, Subject,
                Language, ThreadId, ParentThreadId, DeliveryCallback, State, false);
        }
 
        private async Task SendMessage(XmppClient Client, E2ETransmission E2ETransmission, QoSLevel QoS,
            MessageType Type, string Id, string To, string CustomXml, string Body, string Subject,
            string Language, string ThreadId, string ParentThreadId, EventHandlerAsync<DeliveryEventArgs> DeliveryCallback,
            object State, bool PkiSynchronized)
        {
            if (this.client is null)
                throw new ObjectDisposedException("Endpoint security object disposed.");
 
            if (string.IsNullOrEmpty(Id))
                Id = Client.NextId();
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<message");
 
            switch (Type)
            {
                case MessageType.Chat:
                    Xml.Append(" type=\"chat\"");
                    break;
 
                case MessageType.Error:
                    Xml.Append(" type=\"error\"");
                    break;
 
                case MessageType.GroupChat:
                    Xml.Append(" type=\"groupchat\"");
                    break;
 
                case MessageType.Headline:
                    Xml.Append(" type=\"headline\"");
                    break;
            }
 
            if (!string.IsNullOrEmpty(Language))
            {
                Xml.Append(" xml:lang=\"");
                Xml.Append(XML.Encode(Language));
                Xml.Append('"');
            }
 
            Xml.Append('>');
 
            if (!string.IsNullOrEmpty(Subject))
            {
                Xml.Append("<subject>");
                Xml.Append(XML.Encode(Subject));
                Xml.Append("</subject>");
            }
 
            Xml.Append("<body>");
            Xml.Append(XML.Encode(Body));
            Xml.Append("</body>");
 
            if (!string.IsNullOrEmpty(ThreadId))
            {
                Xml.Append("<thread");
 
                if (!string.IsNullOrEmpty(ParentThreadId))
                {
                    Xml.Append(" parent=\"");
                    Xml.Append(XML.Encode(ParentThreadId));
                    Xml.Append('"');
                }
 
                Xml.Append(">");
                Xml.Append(XML.Encode(ThreadId));
                Xml.Append("</thread>");
            }
 
            if (!string.IsNullOrEmpty(CustomXml))
                Xml.Append(CustomXml);
 
            Xml.Append("</message>");
 
            string MessageXml = Xml.ToString();
            StringBuilder Encrypted = new StringBuilder();
 
            if (await this.Encrypt(Client, Id, string.Empty, this.client.FullJID, To, MessageXml, Encrypted))
            {
                MessageXml = Encrypted.ToString();
 
                await Client.SendMessage(QoS, MessageType.Normal, Id, To, MessageXml, string.Empty,
                    string.Empty, string.Empty, string.Empty, string.Empty, DeliveryCallback, State);
 
                return;
            }
            else if (XmppClient.GetBareJID(To) == To)
            {
                RosterItem Item = Client.GetRosterItem(To);
                bool Found = false;
 
                if (!(Item is null))
                {
                    foreach (PresenceEventArgs e in Item.Resources)
                    {
                        Encrypted.Clear();
 
                        if (await this.Encrypt(Client, Id, string.Empty, this.client.FullJID, e.From, MessageXml, Encrypted))
                        {
                            await Client.SendMessage(QoS, MessageType.Normal, Id, e.From, Encrypted.ToString(), string.Empty,
                                string.Empty, string.Empty, string.Empty, string.Empty, DeliveryCallback, State);
 
                            Found = true;
                        }
                    }
                }
 
                if (Found)
                    return;
            }
 
            if (E2ETransmission == E2ETransmission.IgnoreIfNotE2E)
                return;
 
            if (!PkiSynchronized)
            {
                await this.SynchronizeE2e(To, async (Sender, e) =>
                {
                    if (e.Ok)
                    {
                        await this.SendMessage(Client, E2ETransmission, QoS, Type, Id, To, CustomXml, Body, Subject,
                            Language, ThreadId, ParentThreadId, DeliveryCallback, State, true);
                    }
                    else if (E2ETransmission == E2ETransmission.NormalIfNotE2E)
                    {
                        await Client.SendMessage(QoS, Type, Id, To, CustomXml, Body, Subject, Language,
                            ThreadId, ParentThreadId, DeliveryCallback, State);
                    }
                    else if (!(DeliveryCallback is null))   // null Callbacks are common, and should not result in a warning in sniffers.
                        await DeliveryCallback.Raise(Sender, new DeliveryEventArgs(State, false));
 
                }, State);
            }
            else if (E2ETransmission == E2ETransmission.NormalIfNotE2E)
            {
                await Client.SendMessage(QoS, Type, Id, To, CustomXml, Body, Subject, Language,
                    ThreadId, ParentThreadId, DeliveryCallback, State);
            }
            else
                throw new InvalidOperationException("End-to-End Encryption not available between " + Client.FullJID + " and " + To + ".");
        }
 
        public Task<uint> SendIqGet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "get", Callback, State, Client.DefaultRetryTimeout,
                Client.DefaultNrRetries, Client.DefaultDropOff, Client.DefaultMaxRetryTimeout, false);
        }
 
        public Task<uint> SendIqGet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "get", Callback, State, RetryTimeout, NrRetries, false,
                RetryTimeout, false);
        }
 
        public Task<uint> SendIqGet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries, bool DropOff,
            int MaxRetryTimeout)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "get", Callback, State, RetryTimeout,
                NrRetries, DropOff, MaxRetryTimeout, false);
        }
 
        public Task<uint> SendIqSet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "set", Callback, State,
                Client.DefaultRetryTimeout, Client.DefaultNrRetries, Client.DefaultDropOff,
                Client.DefaultMaxRetryTimeout, false);
        }
 
        public Task<uint> SendIqSet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "set", Callback, State, RetryTimeout,
                NrRetries, false, RetryTimeout, false);
        }
 
        public Task<uint> SendIqSet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries, bool DropOff,
            int MaxRetryTimeout)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "set", Callback, State, RetryTimeout,
                NrRetries, DropOff, MaxRetryTimeout, false);
        }
 
        public Task<uint> SendIqGet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, EventHandlerAsync<DeliveryEventArgs> DeliveryCallback)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "get", Callback, State, Client.DefaultRetryTimeout,
                Client.DefaultNrRetries, Client.DefaultDropOff, Client.DefaultMaxRetryTimeout, false, DeliveryCallback);
        }
 
        public Task<uint> SendIqGet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries, 
            EventHandlerAsync<DeliveryEventArgs> DeliveryCallback)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "get", Callback, State, RetryTimeout, NrRetries, false,
                RetryTimeout, false, DeliveryCallback);
        }
 
        public Task<uint> SendIqGet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries, bool DropOff,
            int MaxRetryTimeout, EventHandlerAsync<DeliveryEventArgs> DeliveryCallback)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "get", Callback, State, RetryTimeout,
                NrRetries, DropOff, MaxRetryTimeout, false, DeliveryCallback);
        }
 
        public Task<uint> SendIqSet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, EventHandlerAsync<DeliveryEventArgs> DeliveryCallback)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "set", Callback, State,
                Client.DefaultRetryTimeout, Client.DefaultNrRetries, Client.DefaultDropOff,
                Client.DefaultMaxRetryTimeout, false, DeliveryCallback);
        }
 
        public Task<uint> SendIqSet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries,
            EventHandlerAsync<DeliveryEventArgs> DeliveryCallback)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "set", Callback, State, RetryTimeout,
                NrRetries, false, RetryTimeout, false, DeliveryCallback);
        }
 
        public Task<uint> SendIqSet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml,
            EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries, bool DropOff,
            int MaxRetryTimeout, EventHandlerAsync<DeliveryEventArgs> DeliveryCallback)
        {
            return this.SendIq(Client, E2ETransmission, null, To, Xml, "set", Callback, State, RetryTimeout,
                NrRetries, DropOff, MaxRetryTimeout, false, DeliveryCallback);
        }
 
        public Task SendIqResult(XmppClient Client, E2ETransmission E2ETransmission, string Id, string To, string Xml)
        {
            return this.SendIq(Client, E2ETransmission, Id, To, Xml, "result", null, null, 0, 0, false, 0, false);
        }
 
        public Task SendIqError(XmppClient Client, E2ETransmission E2ETransmission, string Id, string To, string Xml)
        {
            return this.SendIq(Client, E2ETransmission, Id, To, Xml, "error", null, null, 0, 0, false, 0, false);
        }
 
        public async Task SendIqError(XmppClient Client, E2ETransmission E2ETransmission, string Id, string To,
            Exception ex)
        {
            await this.SendIqError(Client, E2ETransmission, Id, To, await Client.ExceptionToXmppXml(ex));
        }
 
        protected Task<uint> SendIq(XmppClient Client, E2ETransmission E2ETransmission, string Id, string To, string Xml,
            string Type, EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries, bool DropOff,
            int MaxRetryTimeout, bool PkiSynchronized)
        {
            return this.SendIq(Client, E2ETransmission, Id, To, Xml, Type, Callback, State, RetryTimeout, NrRetries, DropOff, 
                MaxRetryTimeout, PkiSynchronized, null);
        }
 
        protected async Task<uint> SendIq(XmppClient Client, E2ETransmission E2ETransmission, string Id, string To, string Xml,
            string Type, EventHandlerAsync<IqResultEventArgs> Callback, object State, int RetryTimeout, int NrRetries, bool DropOff,
            int MaxRetryTimeout, bool PkiSynchronized, EventHandlerAsync<DeliveryEventArgs> DeliveryCallback)
        {
            if (this.client is null)
                throw new ObjectDisposedException("Endpoint security object disposed.");
 
            if (string.IsNullOrEmpty(Id))
                Id = Client.NextId();
 
            StringBuilder Encrypted = new StringBuilder();
 
            if (await this.Encrypt(Client, Id, Type, this.client.FullJID, To, Xml, Encrypted))
            {
                string XmlEnc = Encrypted.ToString();
 
                return await Client.SendIq(Id, To, XmlEnc, Type, this.IqResult,
                    new object[] { Callback, State, E2ETransmission, Id, To, Xml, Type, RetryTimeout, NrRetries, DropOff, MaxRetryTimeout, PkiSynchronized },
                    RetryTimeout, NrRetries, DropOff, MaxRetryTimeout, DeliveryCallback);
            }
 
            if (E2ETransmission == E2ETransmission.IgnoreIfNotE2E)
            {
                if (uint.TryParse(Id, out uint SeqNr))
                    return SeqNr;
                else
                    return 0;
            }
 
            if (!PkiSynchronized)
            {
                if (!uint.TryParse(Id, out uint SeqNr))
                {
                    Id = Client.NextId();
                    SeqNr = uint.Parse(Id);
                }
 
                await this.SynchronizeE2e(To, async (Sender, e) =>
                {
                    if (e.Ok)
                    {
                        await this.SendIq(Client, E2ETransmission, Id, To, Xml, Type, Callback, State,
                            RetryTimeout, NrRetries, DropOff, MaxRetryTimeout, true, DeliveryCallback);
                    }
                    else if (E2ETransmission == E2ETransmission.NormalIfNotE2E)
                    {
                        await Client.SendIq(Id, To, Xml, Type, Callback, State, RetryTimeout,
                            NrRetries, DropOff, MaxRetryTimeout, DeliveryCallback);
                    }
                    else
                    {
                        if (!(DeliveryCallback is null))
                            await DeliveryCallback.Raise(Sender, new DeliveryEventArgs(Sender, true));
 
                        await Callback.Raise(Sender, e);
                    }
                }, State);
 
                return SeqNr;
            }
            else if (E2ETransmission == E2ETransmission.NormalIfNotE2E)
            {
                return await Client.SendIq(Id, To, Xml, Type, Callback, State, RetryTimeout,
                    NrRetries, DropOff, MaxRetryTimeout, DeliveryCallback);
            }
            else
                throw new InvalidOperationException("End-to-End Encryption not available between " + Client.FullJID + " and " + To + ".");
        }
 
        public XmlElement IqGet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml, int Timeout)
        {
            Task<XmlElement> Result = this.IqGetAsync(Client, E2ETransmission, To, Xml);
 
            if (!Result.Wait(Timeout))
                throw new TimeoutException();
 
            return Result.Result;
        }
 
        public async Task<XmlElement> IqGetAsync(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml)
        {
            TaskCompletionSource<XmlElement> Result = new TaskCompletionSource<XmlElement>();
 
            await this.SendIqGet(Client, E2ETransmission, To, Xml, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.Response);
                else
                    Result.TrySetException(e.StanzaError ?? new XmppException("Unable to perform IQ Get."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        public XmlElement IqSet(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml, int Timeout)
        {
            Task<XmlElement> Result = this.IqSetAsync(Client, E2ETransmission, To, Xml);
 
            if (!Result.Wait(Timeout))
                throw new TimeoutException();
 
            return Result.Result;
        }
 
        public async Task<XmlElement> IqSetAsync(XmppClient Client, E2ETransmission E2ETransmission, string To, string Xml)
        {
            TaskCompletionSource<XmlElement> Result = new TaskCompletionSource<XmlElement>();
 
            await this.SendIqSet(Client, E2ETransmission, To, Xml, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.Response);
                else
                    Result.TrySetException(e.StanzaError ?? new XmppException("Unable to perform IQ Set."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        public void AppendE2eInfo(StringBuilder Xml)
        {
            Xml.Append("<e2e xmlns=\"");
            Xml.Append(IoTHarmonizationE2ECurrent);
            Xml.Append("\">");
 
            foreach (IE2eEndpoint E2e in this.keys)
                E2e.ToXml(Xml, IoTHarmonizationE2ECurrent);
 
            Xml.Append("</e2e>");
        }
 
        public Task SynchronizeE2e(string FullJID, EventHandlerAsync<IqResultEventArgs> Callback)
        {
            return this.SynchronizeE2e(FullJID, Callback, null);
        }
 
        public async Task SynchronizeE2e(string FullJID, EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            LinkedList<SynchRec> CallbackList;
 
            lock (this.synchronizationTasks)
            {
                SynchRec Rec = new SynchRec()
                {
                    Callback = Callback,
                    State = State
                };
 
                if (this.synchronizationTasks.TryGetValue(FullJID, out CallbackList))
                {
                    CallbackList.AddLast(Rec);
                    return;
                }
 
                CallbackList = new LinkedList<SynchRec>();
                CallbackList.AddLast(Rec);
 
                this.synchronizationTasks[FullJID] = CallbackList;
            }
 
            await this.client.SendIqSet(FullJID, this.GetE2eXml(), async (Sender, e) =>
            {
                lock (this.synchronizationTasks)
                {
                    if (!this.synchronizationTasks.TryGetValue(FullJID, out CallbackList))
                        return;
 
                    this.synchronizationTasks.Remove(FullJID);
                }
 
                if (e.Ok && !(e.FirstElement is null))
                    await this.ParseE2e(e.FirstElement, FullJID);
 
                foreach (SynchRec Rec in CallbackList)
                {
                    e.State = Rec.State;
                    await Rec.Callback.Raise(Sender, e);
                }
            }, State);
        }
 
        private readonly Dictionary<string, LinkedList<SynchRec>> synchronizationTasks = new Dictionary<string, LinkedList<SynchRec>>();
 
        private class SynchRec
        {
            public EventHandlerAsync<IqResultEventArgs> Callback;
            public object State;
        }
 
        private string GetE2eXml()
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<synchE2e xmlns=\"");
            Xml.Append(IoTHarmonizationE2ECurrent);
            Xml.Append("\">");
 
            this.AppendE2eInfo(Xml);
            this.serverlessMessaging?.AppendP2pInfo(Xml);
 
            Xml.Append("</synchE2e>");
 
            return Xml.ToString();
        }
 
        private async Task ParseE2e(XmlElement E, string RemoteFullJID)
        {
            XmlElement E2E = null;
            XmlElement P2P = null;
 
            if (!(E is null) && E.LocalName == "synchE2e")
            {
                foreach (XmlNode N in E.ChildNodes)
                {
                    if (N is XmlElement E2)
                    {
                        switch (E2.LocalName)
                        {
                            case "e2e":
                                if (Array.IndexOf(NamespacesIoTHarmonizationE2E, E.NamespaceURI) >= 0)
                                    E2E = E2;
                                break;
 
                            case "p2p":
                                if (Array.IndexOf(NamespacesIoTHarmonizationP2P, E.NamespaceURI) >= 0)
                                    P2P = E2;
                                break;
                        }
                    }
                }
            }
 
            bool HasE2E = this.AddPeerPkiInfo(RemoteFullJID, E2E);
            bool HasP2P = !(this.serverlessMessaging is null) && await this.serverlessMessaging.AddPeerAddressInfo(RemoteFullJID, P2P);
 
            await this.PeerUpdated.Raise(this, new PeerSynchronizedEventArgs(RemoteFullJID, HasE2E, HasP2P));
        }
 
        private async Task SynchE2eHandler(object Sender, IqEventArgs e)
        {
            RosterItem Item;
 
            if (e.FromBareJid != this.client.BareJID &&
                ((Item = this.client.GetRosterItem(e.FromBareJid)) is null ||
                Item.State == SubscriptionState.None ||
                Item.State == SubscriptionState.Remove ||
                Item.State == SubscriptionState.Unknown))
            {
                throw new ForbiddenException("Access denied. Unable to synchronize E2EE.", e.IQ);
            }
 
            await this.ParseE2e(e.Query, e.From);
            await e.IqResult(this.GetE2eXml());
        }
 
        private async Task Client_OnPresence(object Sender, PresenceEventArgs e)
        {
            switch (e.Type)
            {
                case PresenceType.Available:
                    XmlElement E2E = null;
                    XmlElement P2P = null;
 
                    foreach (XmlNode N in e.Presence.ChildNodes)
                    {
                        if (N is XmlElement E)
                        {
                            switch (E.LocalName)
                            {
                                case "e2e":
                                    if (Array.IndexOf(NamespacesIoTHarmonizationE2E, E.NamespaceURI) >= 0)
                                        E2E = E;
                                    break;
 
                                case "p2p":
                                    if (Array.IndexOf(NamespacesIoTHarmonizationP2P, E.NamespaceURI) >= 0)
                                        P2P = E;
                                    break;
                            }
                        }
                    }
 
                    bool HasE2E = this.AddPeerPkiInfo(e.From, E2E);
                    bool HasP2P = !(this.serverlessMessaging is null) && await this.serverlessMessaging.AddPeerAddressInfo(e.From, P2P);
 
                    await this.PeerAvailable.Raise(this, new AvailableEventArgs(e, HasE2E, HasP2P));
                    break;
 
                case PresenceType.Unavailable:
                    await this.PeerUnavailable.Raise(this, e);
                    break;
            }
        }
 
        public event EventHandlerAsync<AvailableEventArgs> PeerAvailable = null;
 
        public event EventHandlerAsync<PresenceEventArgs> PeerUnavailable = null;
 
        public event EventHandlerAsync<PeerSynchronizedEventArgs> PeerUpdated = null;
 
        public IE2eEndpoint GetLocalKey(IE2eEndpoint Key)
        {
            return this.GetLocalKey(Key.GetType());
        }
 
        public IE2eEndpoint GetLocalKey(Type KeyType)
        {
            foreach (IE2eEndpoint Endpoint in this.keys)
            {
                if (Endpoint.GetType() == KeyType)
                    return Endpoint;
            }
 
            if (!typeof(IE2eEndpoint).GetTypeInfo().IsAssignableFrom(KeyType.GetTypeInfo()))
                throw new ArgumentException("Not assignable from " + typeof(IE2eEndpoint).FullName, nameof(KeyType));
 
            return null;
        }
 
        public IE2eEndpoint GetLocalKey(byte[] PublicKey)
        {
            if (PublicKey is null)
                return null;
 
            string s = Convert.ToBase64String(PublicKey);
 
            foreach (IE2eEndpoint Endpoint in this.keys)
            {
                if (Endpoint.PublicKeyBase64 == s)
                    return Endpoint;
            }
 
            return null;
        }
 
    }
}