PaceProtocol.cs

using System;
using System.Globalization;
using System.Security.Cryptography;
using System.Threading.Tasks;
using System.Xml;
using NeuroAccess.Nfc.TravelDocuments.Security;
using Waher.Runtime.Inventory;
using Waher.Security;
 
namespace NeuroAccess.Nfc.TravelDocuments.PACE
{
    public abstract class PaceProtocol() : SecurityObject, IPaceProtocol
    {
        private System.Numerics.BigInteger version;
        private System.Numerics.BigInteger? parameterId;
        private bool configured;
 
        public abstract Grade SecurityStrength { get; }
 
        public virtual bool ChipAuthenticationMapping => false;
 
        public System.Numerics.BigInteger Version => this.version;
 
        public System.Numerics.BigInteger? ParameterId => this.parameterId;
 
        public abstract int Bits { get; }
 
        public override Grade Supports(string Object)
        {
            return Object == this.Oid ? this.SecurityStrength : Grade.NotAtAll;
        }
 
        public override bool IsConfigured => this.configured;
 
        public override bool Configure(Vector SecurityInfo)
        {
            if (SecurityInfo.Length < 2)
                return false;
 
            if (SecurityInfo[1] is not System.Numerics.BigInteger Version)
                return false;
 
            this.version = Version;
 
            if (SecurityInfo.Length > 3)
                return false;
            else if (SecurityInfo.Length == 2)
            {
                this.configured = true;
                return true;
            }
            else if (SecurityInfo[2] is not System.Numerics.BigInteger ParameterId)
                return false;
            else
            {
                this.parameterId = ParameterId;
                this.configured = true;
                return true;
            }
        }
 
        public abstract byte[] CreateNewKey(byte[]? Seed, ref int Index);
 
        public abstract byte[] ImportKey(XmlDocument Xml);
 
        public abstract IPaceProtocol CreateEphemeralKey();
 
        public virtual byte[] GetSharedSecret(byte[] RemotePublicKey)
        {
            // TODO
            throw new NotImplementedException("This protocol does not implement ephemeral key generation.");
        }
 
        public virtual Task<bool> Authenticate(TravelDocumentsClient Client)
        {
            return Task.FromResult(false);
        }
 
        public byte[] KDFπ(DocumentInformation Info)
        {
            return TravelDocumentsClient.KDF(TravelDocumentsClient.PACE_K(Info), 3,
                this.AdjustParity, this.KdfHashFunction, this.KdfHashKeyLength);
        }
 
        public byte[] KDF_Enc(byte[] KSeed)
        {
            return TravelDocumentsClient.KDF(KSeed, 1, this.AdjustParity, this.KdfHashFunction, this.KdfHashKeyLength);
        }
 
        public byte[] KDF_Mac(byte[] KSeed)
        {
            return TravelDocumentsClient.KDF(KSeed, 2, this.AdjustParity, this.KdfHashFunction, this.KdfHashKeyLength);
        }
 
        public virtual bool AdjustParity => false;
 
        public virtual HashFunctionArray KdfHashFunction => Hashes.ComputeSHA1Hash;
 
        public virtual int KdfHashKeyLength => 16;
 
        public virtual int BlockLength => 16;
 
        public byte[] DecryptNonce(DocumentInformation Info, byte[] EncryptedNonce)
        {
            byte[] Kπ = this.KDFπ(Info);
            return this.DecryptNonce(Kπ, EncryptedNonce);
        }
 
        public virtual byte[] DecryptNonce(byte[] Kπ, byte[] EncryptedNonce)
        {
            return this.DecryptAes(Kπ, zeroIv16, EncryptedNonce);
        }
 
        public static byte[] CreateAssociatedData(string Oid, byte[] PublicKey)
        {
            string[] OidParts = Oid.Split('.');
            int i, c = OidParts.Length;
            byte[] OidBytes = new byte[c];
 
            for (i = 0; i < c; i++)
                OidBytes[i] = byte.Parse(OidParts[i], CultureInfo.InvariantCulture);
 
            int d = PublicKey.Length;
            byte[] AssociatedData = new byte[7 + c + d];
 
            AssociatedData[0] = 0x7f;
            AssociatedData[1] = 0x49;
            AssociatedData[2] = (byte)(4 + c + d);
            AssociatedData[3] = 0x06;
            AssociatedData[4] = (byte)(c - 1);
 
            Buffer.BlockCopy(OidBytes, 1, AssociatedData, 5, c - 1);
            i = 4 + c;
 
            AssociatedData[i++] = 0x86;
            AssociatedData[i++] = (byte)(1 + d);
            AssociatedData[i++] = 0x04;
 
            Buffer.BlockCopy(PublicKey, 0, AssociatedData, i, d);
 
            return AssociatedData;
        }
 
        public abstract CMac GetAuthenticator(byte[] Key);
 
        public virtual byte[] Encrypt(byte[] Key, byte[] IV, byte[] Data)
        {
            return this.EncryptAes(Key, IV, Data);
        }
 
        public virtual byte[] Decrypt(byte[] Key, byte[] IV, byte[] Data)
        {
            return this.DecryptAes(Key, IV, Data);
        }
        protected byte[] EncryptAes(byte[] Key, byte[] IV, byte[] Data)
        {
            using Aes Cipher = Aes.Create();
            Cipher.Mode = CipherMode.CBC;
            Cipher.Padding = PaddingMode.None;
            Cipher.BlockSize = this.BlockLength << 3;
            Cipher.KeySize = Key.Length << 3;
 
            using ICryptoTransform Encryptor = Cipher.CreateEncryptor(Key, IV);
 
            return Encryptor.TransformFinalBlock(Data, 0, Data.Length);
        }
 
        protected byte[] Encrypt3Des(byte[] Key, byte[] IV, byte[] Data)
        {
            using TripleDES Cipher = TripleDES.Create();
            Cipher.Mode = CipherMode.CBC;
            Cipher.Padding = PaddingMode.None;
 
            using ICryptoTransform Encryptor = Cipher.CreateEncryptor(Key, IV);
 
            return Encryptor.TransformFinalBlock(Data, 0, Data.Length);
        }
 
        protected byte[] DecryptAes(byte[] Key, byte[] IV, byte[] EncryptedData)
        {
            using Aes Cipher = Aes.Create();
            Cipher.Mode = CipherMode.CBC;
            Cipher.Padding = PaddingMode.None;
            Cipher.BlockSize = this.BlockLength << 3;
            Cipher.KeySize = Key.Length << 3;
 
            using ICryptoTransform Decryptor = Cipher.CreateDecryptor(Key, IV);
 
            return Decryptor.TransformFinalBlock(EncryptedData, 0, EncryptedData.Length);
        }
 
        protected byte[] Decrypt3Des(byte[] Key, byte[] IV, byte[] EncryptedData)
        {
            using TripleDES Cipher = TripleDES.Create();
            Cipher.Mode = CipherMode.CBC;
            Cipher.Padding = PaddingMode.None;
 
            using ICryptoTransform Decryptor = Cipher.CreateDecryptor(Key, IV);
            
            return Decryptor.TransformFinalBlock(EncryptedData, 0, EncryptedData.Length);
        }
 
        protected static readonly byte[] zeroIv16 = new byte[16];
 
        protected static readonly byte[] zeroIv8 = new byte[8];
    }
}