using System;

using System.Text;

​

namespace ConsoleApp1

{

    public class Program

    {

        public static void Main()

        {

            //wzr_1166dhp_jp_213 OK

            {

                byte seed = 0x2e;

                var encrypt = BytesConvert.FromHexString("527f2446612f01256b2afc89");

                bool isLongstate = false;

                var key = GenerateKey("Buffalo");

​

                var result = BuffaloEnc.Bcrypt_Buf(seed, in key, ref encrypt, 0, encrypt.Length, isLongstate);

​

                Console.WriteLine($"{result} {Encoding.ASCII.GetString(encrypt)}");

            }

            //wsr_3200ax4s_jp_110 OK

            {

                byte seed = 0x72;

                var encrypt = BytesConvert.FromHexString("54525924333a3b3049583c5506");

                bool isLongstate = true;

                var key = GenerateKey("Buffalo");

​

                var result = BuffaloEnc.Bcrypt_Buf(seed, in key, ref encrypt, 0, encrypt.Length, isLongstate);

​

                Console.WriteLine($"{result} {Encoding.ASCII.GetString(encrypt)}");

            }

            //wrm_d2133hs_jp_293 NG

            {

                byte seed = 0x64;

                var encrypt = BytesConvert.FromHexString("8acf045e1ecb30c32c123d8c");

                bool isLongstate = true;

                var key = GenerateKey("Buffalo");

​

                var result = BuffaloEnc.Bcrypt_Buf(seed, in key, ref encrypt, 0, encrypt.Length, isLongstate);

​

                Console.WriteLine($"{result} {Encoding.ASCII.GetString(encrypt)}");

            }

​

        }

​

        public static byte[] GenerateKey(string key)

        {

            var keyBytes = new byte[key.Length + 1];

            Array.Copy(Encoding.ASCII.GetBytes(key), 0, keyBytes, 0, key.Length);

            return keyBytes;

        }

​

        //https://github.com/musashino205/firmware-wintools/tree/master/firmware-wintools/Tools/buffalo-toolsから移植

        public class BuffaloEnc

        {

            public struct Bcrypt_ctx

            {

                public ulong i;

                public ulong j;

                public byte[] buf;

                public long buf_len;

            }

            public const int BCRYPT_DEFAULT_STATE_LEN = 256;

            public const int BCRYPT_MAX_KEYLEN = 254;

​

​

            public static int Bcrypt_Buf(byte seed, in byte[] key, ref byte[] src,

                int offset, int len, bool longstate)

            {

                byte[] bckey = new byte[BCRYPT_MAX_KEYLEN + 1];

                int keylen;

                Bcrypt_ctx ctx = new Bcrypt_ctx();

​

                ctx.buf = null;

​

                /* setup decryption key */

                keylen = key.Length;

                bckey[0] = seed;

                Array.Copy(key, 0, bckey, 1, keylen);

​

                // NULL終端済の場合はインクリメントしない

                if (key[key.Length - 1] != 0)

                    keylen++;

​

                if (Bcrypt_Init(ref ctx, in bckey, keylen,

                    longstate ? len : BCRYPT_DEFAULT_STATE_LEN) != 0)

                    return 1;

​

                Bcrypt_Process(ref ctx, ref src, offset, len);

​

                return 0;

            }

​

            private static int Bcrypt_Init(ref Bcrypt_ctx ctx, in byte[] key, int keylen,

                int state_len)

            {

                int k = 0;

                int i, j;

​

                ctx.buf = new byte[state_len];

​

                ctx.i = ctx.j = 0;

                ctx.buf_len = state_len;

​

                for (i = 0; i < state_len; i++)

                    ctx.buf[i] = (byte)i;

​

                for (i = 0, j = 0; i < state_len; i++, j = (j + 1) % keylen)

                {

                    byte t;

​

                    t = ctx.buf[i];

                    k = (k + key[j] + t) % state_len;

                    ctx.buf[i] = ctx.buf[k];

                    ctx.buf[k] = t;

                }

​

                return 0;

            }

​

            private static void Bcrypt_Process(ref Bcrypt_ctx ctx, ref byte[] src,

                int offset, int len)

            {

                byte i, j;

​

                i = Convert.ToByte(ctx.i);

                j = Convert.ToByte(ctx.j);

​

                for (int k = 0; k < len; k++)

                {

                    byte t;

​

                    i = (byte)((uint)(i + 1) % ctx.buf_len);

                    j = (byte)((uint)(j + ctx.buf[i]) % ctx.buf_len);

                    t = ctx.buf[j];

                    ctx.buf[j] = ctx.buf[i];

                    ctx.buf[i] = t;

​

                    if (offset >= 0)

                        src[k] = (byte)(src[k + offset] ^ ctx.buf[(uint)(ctx.buf[i] + ctx.buf[j]) % ctx.buf_len]);

                    else

                        src[k + -offset] = (byte)(src[k + -offset] ^ ctx.buf[(uint)(ctx.buf[i] + ctx.buf[j]) % ctx.buf_len]);

                }

​

                ctx.i = i;

                ctx.j = j;

            }

        }

​

        public class BytesConvert

        {

            public static string ToHexString(byte[] bytes)

            {

                if (bytes == null)

                {

                    return string.Empty;

                }

                StringBuilder sb = new StringBuilder(bytes.Length * 2);

                foreach (byte b in bytes)

                {

                    if (b < 16) sb.Append('0');

                    sb.Append(Convert.ToString(b, 16));

                }

                return sb.ToString();

            }

            public static byte[] FromHexString(string str)

            {

                int length = str.Length / 2;

                byte[] bytes = new byte[length];

                int j = 0;

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

                {

                    bytes[i] = Convert.ToByte(str.Substring(j, 2), 16);

                    j += 2;

                }

                return bytes;

            }

        }

    }

}

​