C# перенос кода в функцию [закрыт]

Есть код для высчитывания HMAC, писал как черновой вариант для дальнейшего переноса в функцию. Такой вариант считает всё верно, но после переноса в функцию считает уже неверно. Проходил много раз по коду по шагам, вроде должно работать, но не работает. Выручайте, пожалуйста. Код обеих программ в приложении

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

namespace hmac
{
    class Program
    {
        static void Main(string[] args) //https://ru.wikipedia.org/wiki/HMAC
        {
            HashAlgorithm sha256 = SHA256.Create();
            int blocksize = 64;
            string text = "sample text";
            byte[] byte_text = Encoding.UTF8.GetBytes(text);

            string privateKey = "privatekey"; 
            byte[] bytes = Encoding.UTF8.GetBytes(privateKey); // ключ в байтах
            byte[] privateKey64 = new byte[blocksize];
            byte[] newbytes = new byte[blocksize]; //будет хранить байты  результата XOR ключа с байтом 0х36 при размере блока 64 байта 
            byte[] concat = new byte[byte_text.Length + newbytes.Length]; //хранение склейки байтов исходного сообщения и байтов ipad
            for (int i = 0; i < bytes.Length; i++)
            {
                privateKey64[i] = bytes[i];
            }
            for (int i = bytes.Length; i < blocksize; i++)
            {
                privateKey64[i] += 0x0;
            }

            int[] int_privateKey64 = new int[blocksize];
            for (int i = 0; i < blocksize; i++)
            {
                int_privateKey64[i] = (int)privateKey64[i];
            }

            byte ipad = 0x36;
            byte opad = 0x5C;
            int int_opad = (int)opad;
            int int_ipad = (int)ipad;
            int[] int_kXopad = new int[blocksize];
            int[] int_newbytes = new int[blocksize];
            //XOR дополненного ключа с 0х5с
            for (int i = 0; i < blocksize; i++)
            {
                int_kXopad[i] = int_privateKey64[i] ^ int_opad;
            }
            //Превод в байты ксора ключа и 0х5с
            byte[] kXopad = new byte[blocksize];
            for (int i = 0; i < blocksize; i++)
            {
                kXopad[i] = (byte)int_kXopad[i];
            }

            for (int i = 0; i < blocksize; i++)
            {
                int_newbytes[i] = int_privateKey64[i] ^ int_ipad;
            }
            for (int i = 0; i < blocksize; i++)
            {
                newbytes[i] = (byte)int_newbytes[i];
            }

            //Шаг 3. Выполняем склейку исходного сообщения со строкой, полученной на шаге 2.
            int j = 0;
            for (int i = 0; i < newbytes.Length; i++)
            {
                concat[i] = newbytes[i];
            }
            for (int i = newbytes.Length; i < concat.Length; i++)
            {
                concat[i] += byte_text[j];
                j++;
            }// конец шага 3

            //Шаг 4.Применим хеш - функцию SHA - 256 к строке, полученной на прошлом шаге.
            byte[] resultHash = sha256.ComputeHash(concat);
            //соединим ксор опада  и ключа c хэшем
            int k = 0;
            byte[] resultToHash = new byte[resultHash.Length + kXopad.Length];
            for (int i = 0; i < kXopad.Length; i++)
            {
                resultToHash[i] = kXopad[i];
            }
            for (int i = kXopad.Length; i < resultToHash.Length; i++)
            {
                resultToHash[i] = resultHash[k];
                k++;
            }

            //Итоговый HMAC SHA-256
            byte[] hmac_result = sha256.ComputeHash(resultToHash);

            Console.WriteLine("HMAC SHA-256");
            StringBuilder builder4 = new StringBuilder();
            for (int i = 0; i < hmac_result.Length; i++)
            {
                builder4.Append(hmac_result[i].ToString("x2"));
                // Console.WriteLine(i);
            }
            Console.WriteLine(builder4);



    using System;
    using System.Text;
    using System.Security.Cryptography;
    namespace hmacFunc
    {
    class Program
    {
        static void Main(string[] args)
        {
            byte[] ComputeHmac(string rawData, string privateKey)
            {
                HashAlgorithm sha256 = SHA256.Create();
                int blocksize = 64;
                byte ipad = 0x36; int int_ipad = (int)ipad;
                byte opad = 0x5C; int int_opad = (int)opad;
                byte[] byte_rawData = Encoding.UTF8.GetBytes(rawData);
                byte[] byte_privateKey = Encoding.UTF8.GetBytes(privateKey);

                //дополненный ключ в байтах
                byte[] byte_privateKey64 = new byte[blocksize];
                for(int i = 0; i < byte_privateKey.Length; i++)
                {
                    byte_privateKey64[i] = byte_privateKey[i];
                }
                for(int i = byte_privateKey.Length; i < byte_privateKey64.Length; i++)
                {
                    byte_privateKey64[i] = 0x0;
                }

                //дополненный ключ в инте для ксора
                int[] int_privateKey64 = new int[blocksize];
                for(int i = 0; i < blocksize; i++)
                {
                    int_privateKey64[i] = (int)byte_privateKey64[i];
                }

                //ксор ключа с opad и перевод в байты
                int[] int_kXopad = new int[blocksize];
                for(int i = 0; i < blocksize; i++)
                {
                    int_kXopad[i] = int_privateKey64[i] ^ int_opad;
                }
                byte[] kXopad = new byte[blocksize];
                for(int i = 0; i < blocksize; i++)
                {
                    kXopad[i] = (byte)int_kXopad[i];
                }

                //ксор ключа с ipad и перевод в байты
                int[] int_kXipad = new int[blocksize];
                for(int i = 0; i < blocksize; i++)
                {
                    int_kXipad[i] = int_privateKey64[i] ^ int_ipad;
                }
                byte[] kXipad = new byte[blocksize];
                for(int i = 0; i < blocksize; i++)
                {
                    kXipad[i] = (byte)int_kXipad[i];
                }

                //конкатенация в байтах (k XOR ipad) || data
                int j = 0;
                byte[] ipadConcatData = new byte[kXipad.Length + byte_rawData.Length];
                for(int i = 0; i < kXipad.Length; i++)
                {
                    ipadConcatData[i] = kXipad[i];
                }
                for(int i = kXipad.Length; i < ipadConcatData.Length; i++)
                {
                    ipadConcatData[i] += byte_rawData[j];
                    j++;
                }

                byte[] hashed_ipadConcatData = sha256.ComputeHash(ipadConcatData);

                // (K XOR opad) || H[ (K XOR ipad) || data ]
                int k = 0;
                byte[] resultToHash = new byte[kXopad.Length + hashed_ipadConcatData.Length];
                for(int i = 0; i < kXopad.Length; i++)
                {
                    resultToHash[i] = kXopad[i];
                }
                for(int i = kXopad.Length; i < hashed_ipadConcatData.Length; i++)
                {
                    resultToHash[i] += hashed_ipadConcatData[k];
                    k++;
                }

                byte[] hmac_result = sha256.ComputeHash(resultToHash);
                return hmac_result;
            }
            string text = "sample text";
            string key = "privatekey";
            byte[] hmac = ComputeHmac(text, key);
            Console.WriteLine("HMAC SHA-256");
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < hmac.Length; i++)
            {
                builder.Append(hmac[i].ToString("x2"));
            }
            Console.WriteLine(builder);
        }
    }
}