using System;

using System.Text;

using System.Security.Cryptography;

​

namespace wpapskKey

{

public class Program

{

    public static void Main()

    {

        string pwd="123";

     string ssid="abc";

        Console.WriteLine("Method1:" + WPAPskKey.getWpaPskKeyFromPassphrase(pwd,ssid));

        Console.WriteLine("Method2:" + GetWpaMasterKey(pwd,ssid));

    }

     public static string GetWpaMasterKey(string pwd, string ssid)

        {

            byte[] key = new Rfc2898DeriveBytes(Encoding.UTF8.GetBytes(pwd), Encoding.UTF8.GetBytes(ssid), 4096).GetBytes(32);

            return BitConverter.ToString(key).Replace("-", string.Empty);

        }

} 

​

   public static class WPAPskKey {

        /* pad string to 64 bytes and convert to 16 32-bit words */

        private static uint[] stringtowords(string s, uint padi)

        {

            /* return a 80-word array for later use in the SHA1 code */

            uint[] z = new uint[80];

            var j = -1;

            var k = 0;

            char[] cs = s.ToCharArray();

            var n = s.Length;

            for (var i = 0; i < 64; i++)

            {

                uint c = 0;

                if (i < n)

                {

                    c = cs[i];

                }

                else if (padi > 0)

                {

                    /* add 4-byte PBKDF2 block index and

                   standard padding for the final SHA1 input block */

                    if (i == n) c = ((uint)padi >> 24) & 0xff;

                    else if (i == n + 1) c = (padi >> 16) & 0xff;

                    else if (i == n + 2) c = (padi >> 8) & 0xff;

                    else if (i == n + 3) c = (padi & 0xff);

                    else if (i == n + 4) c = 0x80;

                }

                if (k == 0)

                {

                    j++;

                    z[j] = 0;

                    k = 32;

                }

                k -= 8;

​

                z[j] = z[j] | (c << k);

            }

            if (padi > 0) z[15] = (uint)(8 * (64 + n + 4));

​

            return z;

        }

​

        /* compute the intermediate SHA1 state after processing just

        the 64-byte padded HMAC key */

        private static uint[] initsha(uint[] w, uint padbyte)

        {

            uint pw = (padbyte << 24) | (padbyte << 16) | (padbyte << 8) | padbyte;

​

            for (int i = 0; i < 16; i++)

            {

                w[i] ^= pw;

            }

​

            uint[] s = new uint[] { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };

            uint a = s[0], b = s[1], c = s[2], d = s[3], e = s[4];

​

            uint t;

            for (var k = 16; k < 80; k++)

            {

                t = (uint)(w[k - 3] ^ w[k - 8] ^ w[k - 14] ^ w[k - 16]);

                w[k] = (t << 1) | ((uint)t >> 31);

            }

            for (var k = 0; k < 20; k++)

            {

                t = (uint)(((a << 5) | ((uint)a >> 27)) + e + w[k] + 0x5A827999 + ((b & c) | ((~b) & d)));

                e = d;

                d = c;

                c = (b << 30) | (b >> 2);

                b = a;

                a = t & 0xffffffff;

            }

            for (var k = 20; k < 40; k++)

            {

                t = (uint)(((a << 5) | ((uint)a >> 27)) + e + w[k] + 0x6ED9EBA1 + (b ^ c ^ d));

                e = d;

                d = c;

                c = (b << 30) | ((uint)b >> 2);

                b = a;

                a = t & 0xffffffff;

            }

            for (var k = 40; k < 60; k++)

            {

                t = (uint)(((a << 5) | ((uint)a >> 27)) + e + w[k] + 0x8F1BBCDC + ((b & c) | (b & d) | (c & d)));

                e = d;

                d = c;

                c = (b << 30) | ((uint)b >> 2);

                b = a;

                a = t & 0xffffffff;

            }

            for (var k = 60; k < 80; k++)

            {

                t = ((uint)((a << 5) | ((uint)a >> 27)) + e + w[k] + 0xCA62C1D6 + (b ^ c ^ d));

                e = d;

                d = c;

                c = (b << 30) | ((uint)b >> 2);

                b = a;

                a = t & 0xffffffff;

            }

            s[0] = (s[0] + a) & 0xffffffff;

            s[1] = (s[1] + b) & 0xffffffff;

            s[2] = (s[2] + c) & 0xffffffff;

            s[3] = (s[3] + d) & 0xffffffff;

            s[4] = (s[4] + e) & 0xffffffff;

​

            return s;

        }

​

​

        public static string getWpaPskKeyFromPassphrase(string pass, string salt)

        {

            /* compute the intermediate SHA1 state of the inner and outer parts

               of the HMAC algorithm after processing the padded HMAC key */

            var hmac_istate = initsha(stringtowords(pass, 0), 0x36);

            var hmac_ostate = initsha(stringtowords(pass, 0), 0x5c);

​

            /* output is created in blocks of 20 bytes at a time and collected

               in a string as hexadecimal digits */

            string hash = "";

            uint i = 0;

            while (hash.Length < 64)

            {

                /* prepare 20-byte (5-word) output vector */

                uint[] u = new uint[] { 0, 0, 0, 0, 0 };

                /* prepare input vector for the first SHA1 update (salt + block number) */

                i++;

                uint[] w = stringtowords(salt, i);

                /* iterate 4096 times an inner and an outer SHA1 operation */

                for (int j = 0; j < 2 * 4096; j++)

                {

                    /* alternate inner and outer SHA1 operations */

                    uint[] s = (j & 1) > 0 ? hmac_ostate : hmac_istate;

                    /* inline the SHA1 update operation */

                    uint a = s[0], b = s[1], c = s[2], d = s[3], e = s[4];

​

                    uint t;

                    for (var k = 16; k < 80; k++)

                    {

                        t = w[k - 3] ^ w[k - 8] ^ w[k - 14] ^ w[k - 16];

                        w[k] = (t << 1) | (t >> 31);

                    }

                    for (var k = 0; k < 20; k++)

                    {

                        t = ((a << 5) | (a >> 27)) + e + w[k] + 0x5A827999 + ((b & c) | ((~b) & d));

                        e = d;

                        d = c;

                        c = (b << 30) | (b >> 2);

                        b = a;

                        a = t & 0xffffffff;

                    }

                    for (var k = 20; k < 40; k++)

                    {

                        t = ((a << 5) | (a >> 27)) + e + w[k] + 0x6ED9EBA1 + (b ^ c ^ d);

                        e = d;

                        d = c;

                        c = (b << 30) | (b >> 2);

                        b = a;

                        a = t & 0xffffffff;

                    }

                    for (var k = 40; k < 60; k++)

                    {

                        t = ((a << 5) | (a >> 27)) + e + w[k] + 0x8F1BBCDC + ((b & c) | (b & d) | (c & d));

                        e = d;

                        d = c;

                        c = (b << 30) | (b >> 2);

                        b = a;

                        a = t & 0xffffffff;

                    }

                    for (var k = 60; k < 80; k++)

                    {

                        t = ((a << 5) | (a >> 27)) + e + w[k] + 0xCA62C1D6 + (b ^ c ^ d);

                        e = d;

                        d = c;

                        c = (b << 30) | (b >> 2);

                        b = a;

                        a = t & 0xffffffff;

                    }

                    /* stuff the SHA1 output back into the input vector */

                    w[0] = (s[0] + a) & 0xffffffff;

                    w[1] = (s[1] + b) & 0xffffffff;

                    w[2] = (s[2] + c) & 0xffffffff;

                    w[3] = (s[3] + d) & 0xffffffff;

                    w[4] = (s[4] + e) & 0xffffffff;

                    if ((j & 1) > 0)

                    {

                        /* XOR the result of each complete HMAC-SHA1 operation into u */

                        u[0] ^= w[0];

                        u[1] ^= w[1];

                        u[2] ^= w[2];

                        u[3] ^= w[3];

                        u[4] ^= w[4];

                    }

                    else if (j == 0)

                    {

                        /* pad the new 20-byte input vector for subsequent SHA1 operations */

                        w[5] = 0x80000000;

                        for (var k = 6; k < 15; k++) w[k] = 0;

                        w[15] = 8 * (64 + 20);

                    }

                }

                /* convert output vector u to hex and append to output string */

                for (var j = 0; j < 5; j++)

                    for (var k = 0; k < 8; k++)

                    {

                        var t = (u[j] >> (28 - 4 * k)) & 0x0f;

                        hash += (char)(t + (t < 10 ? 48 : 87));

                    }

            }

​

            /* return the first 32 key bytes as a hexadecimal string */

            return hash.Substring(0, 64);

        }

    }

​

//inherit properties from DeriveBytes

public class Rfc2898DeriveBytes : DeriveBytes 

    { 

        const int BlockSize = 20; 

        uint block; 

        byte[] buffer; 

        int endIndex; 

        readonly HMACSHA1 hmacsha1; 

        uint iterations; 

        byte[] salt; 

        int startIndex; 

        // Create Rfc2898DeriveBytes Constructors

        public Rfc2898DeriveBytes(string password, byte[] salt, int iterations)

         : this(new UTF8Encoding(false).GetBytes(password), salt, iterations) 

        { 

        } 

        public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations) 

        { 

            Salt = salt; 

            IterationCount = iterations; 

            hmacsha1 = new HMACSHA1(password); 

            Initialize(); 

        } 

//get and set salt

public byte[] Salt 

        { 

            get 

            { 

                return (byte[]) salt.Clone(); 

            } 

            set 

            { 

                if (value == null) 

                { 

                    throw new ArgumentNullException("value"); 

                } 

                salt = (byte[]) value.Clone(); 

                Initialize(); 

            } 

}

        //get bytes for DeriveKey()

        static byte[] Int(uint i) 

        { 

            byte[] bytes = BitConverter.GetBytes(i); 

            byte[] buffer2 = new byte[] {bytes[3], bytes[2], bytes[1], bytes[0]}; 

            if (!BitConverter.IsLittleEndian) 

            { 

                return bytes; 

            } 

            return buffer2; 

        } 

 //Derive the key

        byte[] DeriveKey() 

        { 

            byte[] inputBuffer = Int(block); 

            hmacsha1.TransformBlock(salt, 0, salt.Length, salt, 0); 

            hmacsha1.TransformFinalBlock(inputBuffer, 0, inputBuffer.Length); 

            byte[] hash = hmacsha1.Hash; 

            hmacsha1.Initialize(); 

            byte[] buffer3 = hash; 

            for (int i = 2; i <= iterations; i++) 

            { 

                hash = hmacsha1.ComputeHash(hash); 

                for (int j = 0; j < BlockSize; j++) 

                { 

                    buffer3[j] = (byte) (buffer3[j] ^ hash[j]); 

                } 

            } 

            block++; 

            return buffer3; 

        } 

 //Get Bytes of the Generated Key

        public override byte[] GetBytes(int bytesToGet) 

        { 

            if (bytesToGet <= 0) 

            { 

                throw new ArgumentOutOfRangeException("bytesToGet"); 

            } 

            byte[] dst = new byte[bytesToGet]; 

            int dstOffset = 0; 

            int count = endIndex - startIndex; 

            if (count > 0) 

            { 

                if (bytesToGet < count) 

                { 

                    Buffer.BlockCopy(buffer, startIndex, dst, 0, bytesToGet); 

                    startIndex += bytesToGet; 

                    return dst; 

                } 

                Buffer.BlockCopy(buffer, startIndex, dst, 0, count); 

                startIndex = endIndex = 0; 

                dstOffset += count; 

            } 

            while (dstOffset < bytesToGet) 

            { 

                byte[] src = DeriveKey(); 

                int num3 = bytesToGet - dstOffset; 

                if (num3 > BlockSize) 

                { 

                    Buffer.BlockCopy(src, 0, dst, dstOffset, BlockSize); 

                    dstOffset += BlockSize; 

                } 

                else 

                { 

                    Buffer.BlockCopy(src, 0, dst, dstOffset, num3); 

                    dstOffset += num3; 

                    Buffer.BlockCopy(src, num3, buffer, startIndex, BlockSize - num3); 

                    endIndex += BlockSize - num3; 

                    return dst; 

                } 

            } 

            return dst; 

        } 

        void Initialize() 

        { 

            if (buffer != null) 

            { 

                Array.Clear(buffer, 0, buffer.Length); 

            } 

            buffer = new byte[BlockSize]; 

            block = 1; 

            startIndex = endIndex = 0; 

        } 

        public override void Reset() 

        { 

            Initialize(); 

        } 

 //get iteration count

        public int IterationCount 

        { 

            get 

            { 

                return (int) iterations; 

            } 

            set 

            { 

                if (value <= 0) 

                { 

                    throw new ArgumentOutOfRangeException("value"); 

                } 

                iterations = (uint) value; 

                Initialize(); 

            } 

        } 

    }

}