ContractSharedSecretState.cs

using System;
using System.Text;
using Waher.Networking.XMPP.P2P.SymmetricCiphers;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Collections;
using Waher.Runtime.Inventory;
using Waher.Security.CallStack;
 
namespace Waher.Networking.XMPP.Contracts
{
    [CollectionName("ContractSharedSecretStates")]
    [TypeName(TypeNameSerialization.None)]
    [Index("BareJid", "ContractId")]
    public class ContractSharedSecretState : IEncryptedProperties
    {
        private static ICallStackCheck[] approvedSources = null;
 
        private string objectId = null;
        private CaseInsensitiveString bareJid = CaseInsensitiveString.Empty;
        private string contractId = string.Empty;
        private string creatorJid = string.Empty;
        private SymmetricCipherAlgorithms keyAlgorithm = SymmetricCipherAlgorithms.Aes256;
        private byte[] sharedSecret = null;
 
        public ContractSharedSecretState()
        {
        }
 
        public ContractSharedSecretState(string ContractId)
        {
            this.contractId = ContractId;
        }
 
        [ObjectId]
        public string ObjectId
        {
            get => this.objectId;
            set => this.objectId = value;
        }
 
        public CaseInsensitiveString BareJid
        {
            get => this.bareJid;
            set => this.bareJid = value;
        }
 
        public string ContractId
        {
            get => this.contractId;
            set => this.contractId = value;
        }
 
        [DefaultValueStringEmpty]
        public string CreatorJid
        {
            get => this.creatorJid;
            set => this.creatorJid = value;
        }
 
        public SymmetricCipherAlgorithms KeyAlgorithm
        {
            get => this.keyAlgorithm;
            set => this.keyAlgorithm = value;
        }
 
        public bool HasSharedSecret => !(this.sharedSecret is null);
 
        [DefaultValueNull]
        [Encrypted(32)]
        public byte[] SharedSecret
        {
            get
            {
                AssertAllowed();
                return this.sharedSecret;
            }
 
            set
            {
                if (!(this.sharedSecret is null))
                    AssertAllowed();
 
                this.sharedSecret = value;
            }
        }
 
        public string[] EncryptedProperties => new string[]
        {
            nameof(this.SharedSecret)
        };
 
        public static void SetAllowedSources(ICallStackCheck[] ApprovedSources)
        {
            if (!(approvedSources is null))
                throw new NotSupportedException("Changing approved sources not permitted.");
 
            approvedSources = ApprovedSources;
        }
 
        private static void AssertAllowed()
        {
            if (!(approvedSources is null))
                Assert.CallFromSource(approvedSources);
        }
 
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append(this.bareJid);
            sb.Append(", ");
            sb.Append(this.contractId);
            sb.Append(", ");
            sb.Append(this.creatorJid);
            sb.Append(", ");
            sb.Append(this.keyAlgorithm.ToString());
 
            if (!(this.sharedSecret is null))
                sb.Append(", SharedSecret");
 
            return sb.ToString();
        }
    }
}