TotpCalculator.cs

using System;
using System.Threading.Tasks;
 
namespace Waher.Security.TOTP
{
    public class TotpCalculator
    {
        public const int DefaultTimeStepSeconds = 30;
 
        public const long DefaultT0 = 0;
 
        private readonly HotpCalculator hotp;
        private readonly long t0;
        private readonly int timeStepSeconds;
 
        public TotpCalculator(byte[] Secret)
            : this(HotpCalculator.DefaultNrDigits, Secret, HotpCalculator.DefaultHashFunction)
        {
        }
 
        public TotpCalculator(int NrDigits, byte[] Secret)
            : this(NrDigits, Secret, HotpCalculator.DefaultHashFunction)
        {
        }
 
        public TotpCalculator(int NrDigits, byte[] Secret, HashFunction HashFunction)
            : this(NrDigits, Secret, HashFunction, DefaultTimeStepSeconds)
        {
        }
 
        public TotpCalculator(int NrDigits, byte[] Secret, HashFunction HashFunction,
            int TimeStepSeconds)
            : this(NrDigits, Secret, HashFunction, TimeStepSeconds, DefaultT0)
        {
        }
 
        public TotpCalculator(int NrDigits, byte[] Secret, HashFunction HashFunction,
            int TimeStepSeconds, long T0)
        {
            CheckTimeStepSeconds(TimeStepSeconds, T0);
 
            this.timeStepSeconds = TimeStepSeconds;
            this.t0 = T0;
            this.hotp = new HotpCalculator(NrDigits, Secret, HashFunction);
        }
 
        internal static void CheckTimeStepSeconds(int TimeStepSeconds, long T0)
        {
            if (TimeStepSeconds <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(TimeStepSeconds),
                    "Time step must be a positive integer.");
            }
 
            if (T0 < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(T0),
                    "T0 must be a non-negative integer.");
            }
        }
 
        public static async Task<TotpCalculator> TryCreate(string OtpEndpoint)
        {
            ExternalCredential Secret = await ExternalCredential.GetSecret(OtpEndpoint, CredentialAlgorithm.TOTP);
            if (Secret is null || !Secret.HashFunction.HasValue)
                return null;
 
            return new TotpCalculator(Secret.NrDigits, Secret.Secret, Secret.HashFunction.Value,
                Secret.TimeStepSeconds);
        }
 
        public int NrDigits => this.hotp.NrDigits;
 
        public HashFunction HashFunction => this.hotp.HashFunction;
 
        public int TimeStepSeconds => this.timeStepSeconds;
 
        public int Compute()
        {
            return this.Compute(DateTime.UtcNow);
        }
 
        public int Compute(DateTime Timestamp)
        {
            long Counter = CalcCounter(Timestamp, this.timeStepSeconds, this.t0);
            return this.hotp.Compute(Counter);
        }
 
        public static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
        public static int Compute(byte[] Secret, DateTime Timestamp)
        {
            return Compute(HotpCalculator.DefaultNrDigits, Secret, Timestamp);
        }
 
        public static int Compute(int NrDigits, byte[] Secret, DateTime Timestamp)
        {
            return Compute(NrDigits, Secret, HotpCalculator.DefaultHashFunction, Timestamp);
        }
 
        public static int Compute(int NrDigits, byte[] Secret, HashFunction HashFunction,
            DateTime Timestamp)
        {
            return Compute(NrDigits, Secret, HashFunction, DefaultTimeStepSeconds,
                Timestamp, DefaultT0);
        }
 
        public static int Compute(int NrDigits, byte[] Secret, HashFunction HashFunction,
            int TimeStepSeconds, DateTime Timestamp, long T0)
        {
            CheckTimeStepSeconds(TimeStepSeconds, T0);
 
            long Counter = CalcCounter(Timestamp, TimeStepSeconds, T0);
            return HotpCalculator.Compute(NrDigits, Secret, HashFunction, Counter);
        }
 
        public static long CalcCounter(DateTime Timestamp, int TimeStepSeconds, long T0)
        {
            return ((long)Timestamp.ToUniversalTime().Subtract(UnixEpoch).TotalSeconds - T0) / TimeStepSeconds;
        }
 
        public DateTime NextStep
        {
            get
            {
                long Counter = CalcCounter(DateTime.UtcNow, this.timeStepSeconds, this.t0);
                return UnixEpoch.AddSeconds(((Counter + 1) * this.timeStepSeconds) + this.t0);
            }
        }
    }
}