E2eEndpoint.cs

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Runtime.Counters;
 
namespace Waher.Networking.XMPP.P2P.E2E
{
    public abstract class E2eEndpoint : IE2eEndpoint
    {
        private const string E2eCounterName = "E2EE.Counter";
 
        private IE2eSymmetricCipher defaultSymmetricCipher;
        private IE2eEndpoint prev = null;
 
        public E2eEndpoint(IE2eSymmetricCipher DefaultSymmetricCipher)
        {
            this.defaultSymmetricCipher = DefaultSymmetricCipher;
        }
 
        public virtual void Dispose()
        {
            this.defaultSymmetricCipher?.Dispose();
            this.defaultSymmetricCipher = null;
        }
 
        public abstract int SecurityStrength { get; }
 
        public IE2eEndpoint Previous
        {
            get => this.prev;
            set => this.prev = value;
        }
 
        public abstract string LocalName { get; }
 
        public virtual string Namespace => EndpointSecurity.IoTHarmonizationE2ECurrent;
 
        public abstract byte[] PublicKey { get; }
 
        public abstract string PublicKeyBase64 { get; }
 
        public abstract IE2eEndpoint Create(int SecurityStrength);
 
        public abstract IE2eEndpoint CreatePrivate(byte[] Secret);
 
        public abstract IE2eEndpoint CreatePublic(byte[] PublicKey);
 
        public IE2eEndpoint Parse(XmlElement Xml)
        {
            foreach (XmlAttribute Attr in Xml.Attributes)
            {
                switch (Attr.Name)
                {
                    case "pub":
                        return this.CreatePublic(Convert.FromBase64String(Attr.Value));
 
                    case "d":
                        return this.CreatePrivate(Convert.FromBase64String(Attr.Value));
                }
            }
 
            return null;
        }
 
 
        public string ToXml()
        {
            return this.ToXml(string.Empty);
        }
 
        public string ToXml(string ParentNamespace)
        {
            StringBuilder Xml = new StringBuilder();
            this.ToXml(Xml, ParentNamespace);
            return Xml.ToString();
        }
 
        public void ToXml(StringBuilder Xml, string ParentNamespace)
        {
            Xml.Append('<');
            Xml.Append(this.LocalName);
            Xml.Append(" pub=\"");
            Xml.Append(this.PublicKeyBase64);
 
            string ns = this.Namespace;
            if (ns != ParentNamespace)
            {
                Xml.Append("\" xmlns=\"");
                Xml.Append(ns);
            }
 
            Xml.Append("\"/>");
        }
 
        public abstract byte[] GetSharedSecretForEncryption(IE2eEndpoint RemoteEndpoint,
            IE2eSymmetricCipher Cipher, out byte[] CipherText);
 
        public abstract byte[] GetSharedSecretForDecryption(IE2eEndpoint RemoteEndpoint,
            byte[] CipherText);
 
        public abstract bool SharedSecretUseCipherText
        {
            get;
        }
 
        public virtual bool SupportsSignatures => true;
 
        public abstract byte[] Sign(byte[] Data);
 
        public abstract byte[] Sign(Stream Data);
 
        public abstract bool Verify(byte[] Data, byte[] Signature);
 
        public abstract bool Verify(Stream Data, byte[] Signature);
 
        public virtual bool Safe => true;
 
        public virtual bool Slow => false;
 
        public virtual bool PostQuantumCryptography => false;
 
        public override string ToString()
        {
            StringBuilder Xml = new StringBuilder();
            this.ToXml(Xml, string.Empty);
            return Xml.ToString();
        }
 
        public override abstract bool Equals(object obj);
 
        public override abstract int GetHashCode();
 
        public int Score
        {
            get
            {
                int Result = 0;
 
                if (!this.SharedSecretUseCipherText)
                    Result++;
 
                if (this.SupportsSignatures)
                    Result++;
 
                if (this.Safe)
                    Result++;
 
                if (!this.Slow)
                    Result++;
 
                if (this.PostQuantumCryptography)
                    Result += 2;    // To overcome requirement of using cipher texts to derive shared secrets.
 
                return Result;
            }
        }
 
        public virtual IE2eSymmetricCipher DefaultSymmetricCipher
        {
            get => this.defaultSymmetricCipher;
            set => this.defaultSymmetricCipher = value ?? this.defaultSymmetricCipher;
        }
 
        public async Task<uint> GetNextCounter()
        {
            return (uint)await RuntimeCounters.IncrementCounter(E2eCounterName);
        }
    }
}