MGF1.cs

using System;
using NeuroAccess.Nfc.TravelDocuments.Security.HashFunctions;
 
namespace NeuroAccess.Nfc.TravelDocuments.Security.MaskGenerationFunctions
{
    public class MGF1(HashFunction HashFunction) : MaskGenerationFunction
    {
        private static readonly HashFunction defaultHashFunction = new Sha1();
 
        private HashFunction hashFunction = HashFunction;
        private bool configured;
 
        public MGF1()
            : this(defaultHashFunction)
        {
        }
 
        public override string Oid => "1.2.840.113549.1.1.8";
 
        public override bool IsConfigured => this.configured;
 
        public override bool Configure(Vector SecurityInfo)
        {
            if (SecurityInfo.Length >= 2)
            {
                if (SecurityInfo[1] is not HashFunction HashFunction)
                {
                    if (SecurityInfo[1] is Vector v &&
                        v.Length == 1 &&
                        v.FirstElement is HashFunction HashFunction2)
                    {
                        HashFunction = HashFunction2;
                    }
                    else
                        return false;
                }
 
                this.hashFunction = HashFunction;
            }
 
            this.configured = true;
 
            return true;
        }
 
        public override string ToString()
        {
            return "MGF1(" + this.hashFunction.ToString() + ")";
        }
 
        public override byte[] CalculateMask(byte[] Seed, int Length)
        {
            if (Length < 0)
                throw new ArgumentOutOfRangeException(nameof(Length), "Length must be non-negative.");
 
            byte[] Result = new byte[Length];
            byte[] C = new byte[Seed.Length + 4];
            int i = 0;
 
            Buffer.BlockCopy(Seed, 0, C, 0, Seed.Length);
 
            while (true)
            {
                byte[] T = this.hashFunction.ComputeHash(C);
                int d = Math.Min(T.Length, Length - i);
 
                Buffer.BlockCopy(T, 0, Result, i, d);
                i += d;
 
                if (i == Length)
                    return Result;
 
                d = C.Length;
                while (d > 0)
                {
                    if (++C[--d] != 0)
                        break;
                }
            }
        }
    }
}