HotpCalculator.cs

using System;
using System.Threading.Tasks;
 
namespace Waher.Security.TOTP
{
    public class HotpCalculator
    {
        public const int DefaultNrDigits = 6;
 
        public const HashFunction DefaultHashFunction = HashFunction.SHA1;
 
        private readonly int nrDigits;
        private readonly byte[] secret;
        private readonly HashFunction hashFunction;
 
        public HotpCalculator(byte[] Secret)
            : this(DefaultNrDigits, Secret, DefaultHashFunction)
        {
        }
 
        public HotpCalculator(int NrDigits, byte[] Secret)
            : this(NrDigits, Secret, DefaultHashFunction)
        {
        }
 
        public HotpCalculator(int NrDigits, byte[] Secret, HashFunction HashFunction)
        {
            CheckNrDigits(NrDigits);
            CheckSecret(Secret);
 
            this.nrDigits = NrDigits;
            this.secret = Secret;
            this.hashFunction = HashFunction;
        }
 
        internal static void CheckNrDigits(int NrDigits)
        {
            if (NrDigits < 6)
            {
                throw new ArgumentOutOfRangeException(nameof(NrDigits),
                    "Number of digits must be at least 6.");
            }
 
            if (NrDigits > 8)
            {
                throw new ArgumentOutOfRangeException(nameof(NrDigits),
                    "Number of digits must be at most 8.");
            }
        }
 
        internal static void CheckSecret(byte[] Secret)
        {
            if (Secret is null)
                throw new ArgumentNullException(nameof(Secret));
 
            if (Secret.Length == 0)
                throw new ArgumentException("Secret must have a length greater than zero.", nameof(Secret));
        }
 
        public int NrDigits => this.nrDigits;
 
        public HashFunction HashFunction => this.hashFunction;
 
        public static async Task<HotpCalculator> TryCreate(string OtpEndpoint)
        {
            ExternalCredential Secret = await ExternalCredential.GetSecret(OtpEndpoint, CredentialAlgorithm.HOTP);
            if (Secret is null || !Secret.HashFunction.HasValue)
                return null;
 
            return new HotpCalculator(Secret.NrDigits, Secret.Secret, Secret.HashFunction.Value);
        }
 
        public int Compute(long Counter)
        {
            return Compute(this.nrDigits, this.secret, this.hashFunction, Counter);
        }
 
        public static int Compute(byte[] Secret, long Counter)
        {
            return Compute(DefaultNrDigits, Secret, Counter);
        }
 
        public static int Compute(int NrDigits, byte[] Secret, long Counter)
        {
            return Compute(NrDigits, Secret, DefaultHashFunction, Counter);
        }
 
        public static int Compute(int NrDigits, byte[] Secret, HashFunction HashFunction,
            long Counter)
        {
            CheckNrDigits(NrDigits);
            CheckSecret(Secret);
 
            byte[] Data = new byte[8];
            int i;
 
            for (i = 7; i >= 0; i--)
            {
                Data[i] = (byte)Counter;
                Counter >>= 8;
            }
 
            byte[] HMAC = Hashes.ComputeHMACHash(HashFunction, Secret, Data);
            int Offset = HMAC[^1] & 0x0f;
            int Nr = 0;
 
            for (i = 0; i < 4; i++)
            {
                Nr <<= 8;
                Nr |= HMAC[Offset++];
            }
 
            Nr &= 0x7fffffff;
 
            int Divisor = (int)Math.Pow(10, NrDigits);
 
            return Nr % Divisor;
        }
    }
}