Реализация SRP6 World of Warcraft

using System;
using System.Numerics;
using System.Security.Cryptography;
using System.Text;
using System.Globalization;
 
namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            var srp = new SRP6a();
 
            var account = "trumpetx";
            var password = "trumpetx";
 
            srp.CalculateX(account, password);
 
            var S = srp.S.Reverse().ToHexString();
            var V = srp.V.Reverse().ToHexString();
 
            Console.WriteLine($"S {S}");
            Console.WriteLine($"V {V}");
            Console.ReadLine();
        }
    }
 
    public sealed class SRP6a
    {
        public byte[] V { get; private set; }
        public readonly byte[] S;
 
        private readonly SHA1 sha1;
        private readonly BigInteger g;
        private readonly BigInteger N;
 
        public SRP6a()
        {
            sha1 = new SHA1Managed();
 
            //S = GenerateS();
            S = "26bbbcd54d217f7cb3f21244e87d12e3f623dbe9be42e2ccf2b197b29930206c".ToByteArray().Reverse();
            N = BigInteger.Parse("00894B645E89E1535BBDAD5B8B290650530801B18EBFBF5E8FAB3C82872A3E9BB7", NumberStyles.HexNumber);
            g = new byte[] { 7 }.ToBigInteger();
        }
 
        public void CalculateX(string accountName, string password)
        {
            var p = sha1.ComputeHash(Encoding.UTF8.GetBytes((accountName + ":" + password).ToUpper()));
            var x = sha1.ComputeHash(S.Combine(p)).ToBigInteger();
 
            CalculateV(x);
        }
 
        void CalculateV(BigInteger x)
        {
            var v = BigInteger.ModPow(g, x, N);
            V = v.ToByteArray();
        }
 
        private static byte[] GenerateS()
        {
            byte[] S = new byte[0x20];
            using (var rng = RandomNumberGenerator.Create())
                rng.GetBytes(S);
            return S;
        }
    }
 
    public static class Extensions
    {
        public static byte[] Combine(this byte[] data, params byte[][] pData)
        {
            var combined = data;
 
            foreach (var arr in pData)
            {
                var currentSize = combined.Length;
 
                Array.Resize(ref combined, currentSize + arr.Length);
 
                Buffer.BlockCopy(arr, 0, combined, currentSize, arr.Length);
            }
 
            return combined;
        }
 
        public static string ToHexString(this byte[] data)
        {
            var hex = "";
 
            foreach (var b in data)
                hex += string.Format("{0:X2}", b);
 
            return hex.ToUpper();
        }
 
        public static byte[] Reverse(this byte[] data)
        {
            Array.Reverse(data);
            return data;
        }
 
        public static byte[] ToByteArray(this string s)
        {
            var data = new byte[s.Length / 2];
 
            for (int i = 0; i < s.Length; i += 2)
                data[i / 2] = Convert.ToByte(s.Substring(i, 2), 16);
 
            return data;
        }
 
        public static BigInteger ToBigInteger(this byte[] value, bool isBigEndian = false)
        {
            if (isBigEndian)
                Array.Reverse(value);
 
            return new BigInteger(value.Combine(new byte[] { 0 }));
        }
    }
}

using System.Text;
using System.Numerics;
using System.Security.Cryptography;
using System.Globalization;
 
/// <summary>
/// Класс создания s и v для эмулятора WoW CMaNGOS.
/// </summary>
public class SRP6
{
 
    private BigInteger n = BigInteger.Parse("00894B645E89E1535BBDAD5B8B290650530801B18EBFBF5E8FAB3C82872A3E9BB7", NumberStyles.AllowHexSpecifier);
 
    private BigInteger g = new byte[] {7}.ToBigInteger();
 
    private readonly byte[] v = new byte[32];
 
    private readonly byte[] s = new byte[32];
 
    /// <summary>
    /// Только для чтения: Соль.
    /// </summary>
    /// <returns></returns>
    public string Salt
    {
        get
        {
            return s.Reverse().ToHexString;
        }
    }
 
    /// <summary>
    /// Только для чтения: Верификатор.
    /// </summary>
    /// <returns></returns>
    public string Verifier
    {
        get
        {
            return v.Reverse().ToHexString;
        }
    }
 
    /// <summary>
    /// Конструктор инициализации.
    /// </summary>
    /// <param name="username">Имя пользователя.</param>
    /// <param name="password">Пароль.</param>
    /// <param name="salt">Предустановленная соль.</param>
    public SRP6(string username, string password, string salt = "")
    {
 
        if (string.IsNullOrEmpty(salt))
        {
            // Генерим Salt
            using (var rng = RandomNumberGenerator.Create())
            {
                rng.GetBytes(s);
            }
        }
        else
        {
            s = salt.ToByteArray().Reverse();
        }
 
        // Генерим H2 = H(s | H(P))
        var p = SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(username.Trim().ToUpper() + ":" + password.Trim().ToUpper()));
        var h2 = SHA1.Create().ComputeHash(s.Combine(p)).ToBigInteger;
 
        // Генерим v = g ^ H2 % N
        v = BigInteger.ModPow(g, h2, n).ToByteArray();
 
    }
 
}
 
internal static class Extensions
{
 
    public static byte[] Combine(this byte[] data1, byte[] data2)
    {
        return new byte[0].Concat(data1).Concat(data2).ToArray();
    }
 
    public static string ToHexString(this byte[] data)
    {
        StringBuilder hex = new StringBuilder(data.Length * 2);
        foreach (byte b in data)
        {
            hex.AppendFormat("{0:x2}", b);
        }
        return hex.ToString().ToUpper();
    }
 
    public static byte[] ToByteArray(this string s)
    {
        var data = new byte[(s.Length / 2)];
        for (int i = 0; i < s.Length; i += 2)
        {
            data[i / 2] = Convert.ToByte(s.Substring(i, 2), 16);
        }
        return data;
    }
 
    public static BigInteger ToBigInteger(this byte[] value, bool isBigEndian = false)
    {
        if (isBigEndian)
        {
            Array.Reverse(value);
        }
        return new BigInteger(value.Combine(new byte[] {0}));
    }
 
    public static byte[] Reverse(this byte[] data)
    {
        Array.Reverse(data);
        return data;
    }
 
}