MySpace IM Protocol C# .NET

/*****
 *
 * VERY ROUGH IMPLEMENTATION OF MSIM IN C#.NET
 *
 * BY: JOWY :P
 *
 */

MSIM oMSIM = new MSIM(username, password, interface_address);
response = oMSIM.Connect();
oMSIM.ReadPacket();

kv_resp = response.Split(new Char[] { '\\' });

oMSIM.AddPacketVar("login2", "196610");
oMSIM.AddPacketVar("username", username);
oMSIM.AddPacketVar("response", oMSIM.ProcessChallenge(kv_resp[4]));
oMSIM.AddPacketVar("clientver", "823");
oMSIM.AddPacketVar("reconn", "0");
oMSIM.AddPacketVar("status", "100");
oMSIM.AddPacketVar("id", "1");

response = oMSIM.SendPacket();

oMSIM.FlushPacket();

kv_resp = response.Split(new Char[] { '\\' });

if (kv_resp[3] == "sesskey") {
    //LOGGED IN!
}

public class MSIM
{
    TcpClient oTcp;
    Encoding encUTF16LE;
    SHA1 oSha;
    StringBuilder sbPacket;

    string username;
    string password;
    string interface_address;

    public MSIM(string z_username, string z_password, string z_interface_address)
    {
        username = z_username;
        password = z_password;
        interface_address = z_interface_address;

        if (interface_address == "" || interface_address == null)
        {
            oTcp = new TcpClient();
        }
        else
        {
            oTcp = new TcpClient(new IPEndPoint(IPAddress.Parse(interface_address), 0));
        }

        sbPacket = new StringBuilder();
        encUTF16LE = Encoding.GetEncoding("UTF-16LE");
        oSha = new SHA1CryptoServiceProvider();
    }

    public string Connect()
    {
        try
        {
            oTcp.Connect("im.myspace.akadns.net", 1863);
        }
        catch
        {
            return null;
        }

        return ReadPacket();
    }

    public void Close()
    {
        oTcp.Close();
    }

    public string ReadPacket()
    {
        byte[] byte_initial = new byte[4096];

        try
        {
            Stream oStream = oTcp.GetStream();

            oStream.ReadTimeout = 2000;

            oStream.Read(byte_initial, 0, 4096);

            oStream.Flush();
        }
        catch
        {
            return null;
        }

        return Encoding.ASCII.GetString(byte_initial).Replace("\0", "");
    }

    public string SendPacket()
    {
        try
        {
            Stream oStream = oTcp.GetStream();

            byte[] byte_data = Encoding.ASCII.GetBytes((sbPacket.ToString() + "\\final\\").ToCharArray());

            oStream.Write(byte_data, 0, byte_data.Length);
        }
        catch
        {
            return null;
        }

        return ReadPacket();
    }

    public void AddPacketVar(string key, bool value)
    {
        if (value)
        {
            sbPacket.Append("\\" + key + "\\1");
        }
        else
        {
            sbPacket.Append("\\" + key + "\\\\");
        }
    }

    public void AddPacketVar(string key, int value)
    {
        sbPacket.Append("\\" + key + "\\" + value.ToString());
    }

    public void AddPacketVar(string key, string value)
    {
        sbPacket.Append("\\" + key + "\\" + value);
    }

    public void AddPacketVar(string key, byte[] value)
    {
        sbPacket.Append("\\" + key + "\\" + Convert.ToBase64String(value));
    }

    public void FlushPacket()
    {
        sbPacket.Clear();
    }

    public byte[] ProcessChallenge(string challenge)
    {
        byte[] byte_nc1 = new byte[32];
        byte[] byte_nc2 = new byte[32];
        byte[] byte_rc4_key = new byte[16];

        try
        {
            byte[] byte_challenge = Convert.FromBase64String(challenge);

            for (int i = 0; i < 32; i++)
                byte_nc1[i] = byte_challenge[i];

            for (int i = 0; i < 32; i++)
                byte_nc2[i] = byte_challenge[i + 32];
        }
        catch
        {
            return null;
        }

        byte[] byte_password = encUTF16LE.GetBytes(password.ToCharArray());

        byte[] byte_hash_phase1 = oSha.ComputeHash(byte_password);

        byte[] byte_hash_phase2 = new byte[byte_hash_phase1.Length + byte_nc2.Length];

        byte_hash_phase1.CopyTo(byte_hash_phase2, 0);

        byte_nc2.CopyTo(byte_hash_phase2, byte_hash_phase1.Length);

        byte[] byte_hash_total = oSha.ComputeHash(byte_hash_phase2);

        for (int i = 0; i < 16; i++)
            byte_rc4_key[i] = byte_hash_total[i];

        byte[] byte_username = Encoding.ASCII.GetBytes(username.ToCharArray());

        byte[] byte_four_null = new byte[4];

        byte[] byte_network_count = new byte[1];

        byte_network_count[0] = 1;

        byte[] byte_interface_ip = new byte[4];

        byte_interface_ip[0] = 127;
        byte_interface_ip[1] = 0;
        byte_interface_ip[2] = 0;
        byte_interface_ip[3] = 1;

        int l1 = byte_nc1.Length;
        int l2 = byte_username.Length;
        int l3 = byte_four_null.Length;
        int l4 = byte_network_count.Length;
        int l5 = byte_interface_ip.Length;

        byte[] byte_rc4_data = new byte[l1 + l2 + l3 + l4 + l5 + l5];

        byte_nc1.CopyTo(byte_rc4_data, 0);
        byte_username.CopyTo(byte_rc4_data, l1);
        byte_four_null.CopyTo(byte_rc4_data, l1 + l2);
        byte_network_count.CopyTo(byte_rc4_data, l1 + l2 + l3);
        byte_interface_ip.CopyTo(byte_rc4_data, l1 + l2 + l3 + l4);
        byte_interface_ip.CopyTo(byte_rc4_data, l1 + l2 + l3 + l4 + l5);

        return RC4.Encrypt(byte_rc4_key, byte_rc4_data);
    }
}

public static class RC4
{
    public static byte[] Encrypt(byte[] key, byte[] data)
    {
        return EncryptOutput(key, data).ToArray();
    }

    private static byte[] EncryptInitalize(byte[] key)
    {
        byte[] s = Enumerable.Range(0, 256)
           .Select(i => (byte)i)
           .ToArray();

        for (int i = 0, j = 0; i < 256; i++)
        {
            j = (j + key[i % key.Length] + s[i]) & 255;

            Swap(s, i, j);
        }

        return s;
    }

    private static IEnumerable<byte> EncryptOutput(byte[] key, IEnumerable<byte> data)
    {
        byte[] s = EncryptInitalize(key);

        int i = 0;
        int j = 0;

        return data.Select((b) =>
        {
            i = (i + 1) & 255;
            j = (j + s[i]) & 255;

            Swap(s, i, j);

            return (byte)(b ^ s[(s[i] + s[j]) & 255]);
        });
    }

    private static void Swap(byte[] s, int i, int j)
    {
        byte c = s[i];

        s[i] = s[j];
        s[j] = c;
    }
}