using System;
using System.IO;
using System.Text;
using System.Security.Cryptography;

public class rfc2898test
{
    public const int SALT_BYTE_SIZE = 12;
    public const int HASH_BYTE_SIZE = 32;
    public const int PBKDF2_ITERATIONS = 10000;

    public const int ITERATION_INDEX = 1;
    public const int SALT_INDEX = 2;
    public const int PBKDF2_INDEX = 3;

    public static bool ValidatePassword(string password, string correctHash)
    {
        // Extract the parameters from the hash
        char[] delimiter = { '$' };
        string[] split = correctHash.Split(delimiter);
        int iterations = Int32.Parse(split[ITERATION_INDEX]);
        byte[] salt = Convert.FromBase64String(split[SALT_INDEX]);
        byte[] hash = Convert.FromBase64String(split[PBKDF2_INDEX]);

        byte[] testHash = PBKDF2(password, salt, iterations, hash.Length);
        return SlowEquals(hash, testHash);
    }
    private static bool SlowEquals(byte[] a, byte[] b)
    {
        uint diff = (uint)a.Length ^ (uint)b.Length;
        for (int i = 0; i < a.Length && i < b.Length; i++)
            diff |= (uint)(a[i] ^ b[i]);
        return diff == 0;
    }

    private static byte[] PBKDF2(string password, byte[] salt, int iterations, int outputBytes)
    {
        Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(password, salt);
        pbkdf2.IterationCount = iterations;
        return pbkdf2.GetBytes(outputBytes);
    }
    public static string CreateHash(string password)
    {
        // Generate a random salt
        RNGCryptoServiceProvider csprng = new RNGCryptoServiceProvider();
        byte[] salt = new byte[SALT_BYTE_SIZE];
        csprng.GetBytes(salt);

        // Hash the password and encode the parameters
        byte[] hash = PBKDF2(password, salt, PBKDF2_ITERATIONS, HASH_BYTE_SIZE);
        return "pbkdf2_sha256$" + PBKDF2_ITERATIONS + "$" +
            Convert.ToBase64String(salt) + "$" +
            Convert.ToBase64String(hash);
    }


    public static byte[] PBKDF2Sha256GetBytes(int dklen, byte[] password, byte[] salt, int iterationCount)
    {
        using (var hmac = new System.Security.Cryptography.HMACSHA256(password))
        {
            int hashLength = hmac.HashSize / 8;
            if ((hmac.HashSize & 7) != 0)
                hashLength++;
            int keyLength = dklen / hashLength;
            if ((long)dklen > (0xFFFFFFFFL * hashLength) || dklen < 0)
                throw new ArgumentOutOfRangeException("dklen");
            if (dklen % hashLength != 0)
                keyLength++;
            byte[] extendedkey = new byte[salt.Length + 4];
            Buffer.BlockCopy(salt, 0, extendedkey, 0, salt.Length);
            using (var ms = new System.IO.MemoryStream())
            {
                for (int i = 0; i < keyLength; i++)
                {
                    extendedkey[salt.Length] = (byte)(((i + 1) >> 24) & 0xFF);
                    extendedkey[salt.Length + 1] = (byte)(((i + 1) >> 16) & 0xFF);
                    extendedkey[salt.Length + 2] = (byte)(((i + 1) >> 8) & 0xFF);
                    extendedkey[salt.Length + 3] = (byte)(((i + 1)) & 0xFF);
                    byte[] u = hmac.ComputeHash(extendedkey);
                    Array.Clear(extendedkey, salt.Length, 4);
                    byte[] f = u;
                    for (int j = 1; j < iterationCount; j++)
                    {
                        u = hmac.ComputeHash(u);
                        for (int k = 0; k < f.Length; k++)
                        {
                            f[k] ^= u[k];
                        }
                    }
                    ms.Write(f, 0, f.Length);
                    Array.Clear(u, 0, u.Length);
                    Array.Clear(f, 0, f.Length);
                }
                byte[] dk = new byte[dklen];
                ms.Position = 0;
                ms.Read(dk, 0, dklen);
                ms.Position = 0;
                for (long i = 0; i < ms.Length; i++)
                {
                    ms.WriteByte(0);
                }
                Array.Clear(extendedkey, 0, extendedkey.Length);
                return dk;
            }
        }
    }

    public static void Main()
    {
        SHA256 sha = SHA256.Create();

        Rfc2898DeriveBytes ByteMake = new Rfc2898DeriveBytes("123", sha.ComputeHash(UTF8Encoding.UTF8.GetBytes("77riGrGoo5Li")), 10000);
        Console.WriteLine("LpQ5S3g2rY/UsNvw2S+oJX6IqQY2gXJWsPTZ6/T4UKw=");
        Console.WriteLine(Convert.ToBase64String(ByteMake.GetBytes(32)));


        Console.WriteLine("************************");
        if (!ValidatePassword("123", "pbkdf2_sha256$10000$77riGrGoo5Li$LpQ5S3g2rY/UsNvw2S+oJX6IqQY2gXJWsPTZ6/T4UKw="))
        {
            Console.WriteLine("Разные хеши");
        }
        Console.WriteLine("************************");
        Console.WriteLine("pbkdf2_sha256$10000$L6tcM6DUy9n1$egzIW4RnnN7Q1XybwmCaAMXOcG1ZMiufTdNEt5P2/d8=");
        Console.WriteLine(CreateHash("admin"));

        //Вроде бы только этот код работает и можно использовать!
        Console.WriteLine("************************");
        byte[] psw = System.Text.Encoding.UTF8.GetBytes("admin");
        byte[] slt = System.Text.Encoding.UTF8.GetBytes("L6tcM6DUy9n1");
        Console.WriteLine("egzIW4RnnN7Q1XybwmCaAMXOcG1ZMiufTdNEt5P2/d8=");
        Console.WriteLine(Convert.ToBase64String(PBKDF2Sha256GetBytes(32, psw, slt, 10000)));

        Console.ReadLine();
    }
}