using System;

using System.Security.Cryptography;

using System.Text;

using System.Linq;

​

​

// Token: 0x020001AD RID: 429

public class Encoder

{

    // Token: 0x06001130 RID: 4400 RVA: 0x0000F663 File Offset: 0x0000D863

    public static void Validate()

    {

    }

​

    // Token: 0x06001131 RID: 4401 RVA: 0x000A25E8 File Offset: 0x000A07E8

    public static bool CheckKey(string key, out uint id, out uint randomNumber)

    {

        byte[] data = Encoder.Decode(key);

        byte[] data2 = RC4.Cipher("SupportIndieDevelopersWeNeedIt", data);

        id = 0U;

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

        {

            uint num = (uint)((uint)Encoder.ReadBit(data2, 0 + i * 2) << i);

            id |= num;

        }

​

        randomNumber = 0U;

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

        {

            uint num2 = (uint)((uint)Encoder.ReadBit(data2, 1 + j * 2) << j);

            randomNumber |= num2;

        }

​

        uint num3 = (uint)((int)Encoder.ReadByte(data2, 8) << 8 | (int)Encoder.ReadByte(data2, 9));

        uint num4 = id;

        id /= 89U;

        return num4 % 89U == 0U && (uint)Encoder.Digest(data2, 8) == num3;

    }

​

    // Token: 0x06001132 RID: 4402 RVA: 0x000A26AC File Offset: 0x000A08AC

    private static void WriteBit(byte[] data, int loc, byte bit)

    {

        int num = loc / 8;

        int num2 = loc % 8;

        int num3 = num;

        data[num3] |= (byte)((bit & 1) << num2);

    }

​

    // Token: 0x06001133 RID: 4403 RVA: 0x000A26D8 File Offset: 0x000A08D8

    private static byte ReadBit(byte[] data, int loc)

    {

        int num = loc / 8;

        int num2 = loc % 8;

        return (byte)(data[num] >> num2 & 1);

    }

​

    // Token: 0x06001134 RID: 4404 RVA: 0x0000F679 File Offset: 0x0000D879

    private static void WriteByte(byte[] data, int loc, byte b)

    {

        data[loc] = b;

    }

​

    // Token: 0x06001135 RID: 4405 RVA: 0x0000F67F File Offset: 0x0000D87F

    private static byte ReadByte(byte[] data, int loc)

    {

        return data[loc];

    }

​

    // Token: 0x06001136 RID: 4406 RVA: 0x000A26F8 File Offset: 0x000A08F8

    private static ushort Digest(byte[] data, int l)

    {

        byte[] array = new byte[l];

        Array.Copy(data, array, l);

        MD5CryptoServiceProvider md5CryptoServiceProvider = new MD5CryptoServiceProvider();

        byte[] array2 = md5CryptoServiceProvider.ComputeHash(array);

        return (ushort)((int)array2[0] << 8 | (int)array2[1]);

    }

​

    // Token: 0x06001137 RID: 4407 RVA: 0x000A2730 File Offset: 0x000A0930

    public static string Encode(byte[] data)

    {

        string text = string.Empty;

        for (int i = 0; i < data.Length; i++)

        {

            text += Encoder.AlphaMap((int)data[i]);

        }

​

        return Encoder.InsertDashes(text);

    }

​

    // Token: 0x06001138 RID: 4408 RVA: 0x000A276C File Offset: 0x000A096C

    public static byte[] Decode(string data)

    {

        string text = Encoder.RemoveDashes(data);

        byte[] array = new byte[text.Length / 2];

        for (int i = 0; i < text.Length; i += 2)

        {

            char c = text[i];

            char c2 = text[i + 1];

            array[i / 2] = Encoder.AlphaUnmap(c, c2);

        }

​

        return array;

    }

​

    // Token: 0x06001139 RID: 4409 RVA: 0x000A27C8 File Offset: 0x000A09C8

    private static string AlphaMap(int v)

    {

        int num = (int)((uint)(v & 240) >> 4 & 15U);

        int num2 = v & 15;

        char c = Encoder.ALPHABET[num];

        char c2 = Encoder.ALPHABET[num2];

        string str = new string (c, 1);

        string str2 = new string (c2, 1);

        return str + str2;

    }

​

    // Token: 0x0600113A RID: 4410 RVA: 0x000A2814 File Offset: 0x000A0A14

    private static byte AlphaUnmap(char c1, char c2)

    {

        int i;

        for (i = 0; i < Encoder.ALPHABET.Length; i++)

        {

            if (Encoder.ALPHABET[i] == c1)

            {

                break;

            }

        }

​

        byte b = (byte)((i & 15) << 4);

        for (i = 0; i < Encoder.ALPHABET.Length; i++)

        {

            if (Encoder.ALPHABET[i] == c2)

            {

                break;

            }

        }

​

        return (byte)((int)b | (i & 15));

    }

​

    // Token: 0x0600113B RID: 4411 RVA: 0x000A2888 File Offset: 0x000A0A88

    private static string InsertDashes(string data)

    {

        string text = string.Empty;

        for (int i = 0; i < data.Length; i++)

        {

            text += data[i];

            if ((i + 1) % 4 == 0 && i != data.Length - 1)

            {

                text += "-";

            }

        }

​

        return text;

    }

​

    // Token: 0x0600113C RID: 4412 RVA: 0x000A28EC File Offset: 0x000A0AEC

    private static string RemoveDashes(string data)

    {

        string text = string.Empty;

        for (int i = 0; i < data.Length; i++)

        {

            string text2 = new string (data[i], 1);

            if (text2 != "-")

            {

                text += text2;

            }

        }

​

        return text;

    }

​

    // Token: 0x04000F92 RID: 3986

    public static char[] ALPHABET = new char[]{'J', 'N', 'D', 'M', 'G', 'H', 'B', 'K', 'F', 'C', 'P', 'Z', 'R', 'Y', 'W', 'X'};

}

​

// Token: 0x020001D0 RID: 464

public class RC4

{

​

​

    // Token: 0x06001222 RID: 4642 RVA: 0x000AC520 File Offset: 0x000AA720

    public static byte[] Cipher(string skey, string sdata)

    {

        byte[] bytes = Encoding.UTF8.GetBytes(skey);

        byte[] bytes2 = Encoding.UTF8.GetBytes(sdata);

        return RC4.Cipher(bytes, bytes2);

    }

​

    // Token: 0x06001223 RID: 4643 RVA: 0x000AC54C File Offset: 0x000AA74C

    public static byte[] Cipher(string skey, byte[] data)

    {

        byte[] bytes = Encoding.UTF8.GetBytes(skey);

        return RC4.Cipher(bytes, data);

    }

​

    // Token: 0x06001224 RID: 4644 RVA: 0x000AC56C File Offset: 0x000AA76C

    public static byte[] Cipher(byte[] key, byte[] data)

    {

        byte[] array = new byte[256];

        int num = key.Length;

        int num2 = data.Length;

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

        {

            array[i] = (byte)i;

        }

​

        int num3 = 0;

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

        {

            num3 = (num3 + (int)array[j] + (int)key[j % num]) % 256;

            byte b = array[j];

            array[j] = array[num3];

            array[num3] = b;

        }

​

        byte[] array2 = new byte[num2];

        int num4 = 0;

        int num5 = 0;

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

        {

            num4 = (num4 + 1) % 256;

            num5 = (num5 + (int)array[num4]) % 256;

            byte b = array[num4];

            array[num4] = array[num5];

            array[num5] = b;

            array2[k] = (byte)(data[k] ^ array[(int)(array[num4] + array[num5]) % 256]);

        }

​

        return array2;

    }

​

    // Token: 0x06001225 RID: 4645 RVA: 0x000AC660 File Offset: 0x000AA860

    public static byte[] Encrypt(byte[] pwd, byte[] data)

    {

        int[] array = new int[256];

        int[] array2 = new int[256];

        byte[] array3 = new byte[data.Length];

        int i;

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

        {

            array[i] = (int)pwd[i % pwd.Length];

            array2[i] = i;

        }

​

        int num;

        for (i = (num = 0); i < 256; i++)

        {

            num = (num + array2[i] + array[i]) % 256;

            int num2 = array2[i];

            array2[i] = array2[num];

            array2[num] = num2;

        }

​

        int num3;

        num = (num3 = (i = 0));

        while (i < data.Length)

        {

            num3++;

            num3 %= 256;

            num += array2[num3];

            num %= 256;

            int num2 = array2[num3];

            array2[num3] = array2[num];

            array2[num] = num2;

            int num4 = array2[(array2[num3] + array2[num]) % 256];

            array3[i] = (byte)((int)data[i] ^ num4);

            i++;

        }

​

        return array3;

    }

​

    // Token: 0x06001226 RID: 4646 RVA: 0x0000FDEE File Offset: 0x0000DFEE

    public static byte[] Decrypt(byte[] pwd, byte[] data)

    {

        return RC4.Encrypt(pwd, data);

    }

​

    // Token: 0x06001227 RID: 4647 RVA: 0x000AC75C File Offset: 0x000AA95C

    public static string GetHexFromBytes(byte[] bytes)

    {

        char[] array = new char[bytes.Length * 2];

        int i = 0;

        int num = 0;

        while (i < bytes.Length)

        {

            byte b = (byte)(bytes[i] >> 4);

            array[num] = (char)((b <= 9) ? (b + 48) : (b + 55 + 32));

            b = (byte)(bytes[i] & 15);

            array[++num] = (char)((b <= 9) ? (b + 48) : (b + 55 + 32));

            i++;

            num++;

        }

​

        return new string (array);

    }

​

    // Token: 0x06001228 RID: 4648 RVA: 0x000AC7E0 File Offset: 0x000AA9E0

    public static byte[] GetBytesFromHex(string str)

    {

        if (str.Length == 0 || str.Length % 2 != 0)

        {

            return new byte[0];

        }

​

        byte[] array = new byte[str.Length / 2];

        int i = 0;

        int num = 0;

        while (i < array.Length)

        {

            char c = str[num];

            array[i] = (byte)(((c <= '9') ? (c - '0') : ((c <= 'Z') ? (c - 'A' + '\n') : (c - 'a' + '\n'))) << 4);

            c = str[++num];

            byte[] array2 = array;

            int num2 = i;

            array2[num2] |= (byte)((c <= '9') ? (c - '0') : ((c <= 'Z') ? (c - 'A' + '\n') : (c - 'a' + '\n')));

            i++;

            num++;

        }

​

        return array;

    }

}

​

public class Program

{

    public static void Main()

    {

        uint num;

        uint num2;

        while(!flag) {

        string key = "";

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

{

  key += RandomString(4);

      if (i<4 ){key+="-";}  

}

​

        //string key = "JJJJ-JJJJ-JJJJ-JJJJ-JJJJ";

        bool flag = Encoder.CheckKey(key, out num, out num2);

        Console.WriteLine("Hello World " + key + " " + flag);

        }

    }

private static Random random = new Random();

public static string RandomString(int length)

{

    const string chars = "JNDMGHBKFCPZRYWX";

    return new string(Enumerable.Repeat(chars, length)

      .Select(s => s[random.Next(s.Length)]).ToArray());

}

}

​

​