源代码下载

(千万别用此程序乱发广告，更不要跟博客园闪存机器人对闪而刷闪存，后果自负，谢谢)

看到园子里很多朋友对QQ机器人很感兴趣，尤其是c#版本的。
目前C#版本的QQ机器人组件在各大搜索引擎中比较难寻，基于http协议的已经不能再继续使用。

于是就把手里的一份可以登录、收发消息、显示好友等功能的C#版本的基于Udp(和Tcp)协议的QQ机器人组件源码和使用Demo暂时提供下载。
说明：
1.协议基于2005(已经有朋友分析2009的拉)
2.在核心代码里包含了QQ的大部分事件;
3.如果哪位同学把协议更改为2007后，麻烦您发一份到:overred2005@163.com(请把@替换为#撒，逗你玩)，谢谢
4.如果无法登陆，请换个服务器地址试验一下

程序截图：

项目截图：

1.此Demo中惊天大Bug就是使用Timer来处理好友消息，这样会导致有时无法接受到消息！
正确的处理是委托加事件，Core中已经提供，大家能用就用吧，我也懒得改了
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2.欢迎加入博客园QQ机器人研究组交流群：56451610(已满)，群2：56469186(已满)，群共享里有部分资料

如果你想分析协议，提供以下工具：
1.抓包工具：ethereal
2.包调试工具:qqdebugger（群共享里可下载）
3.重量级调试工具:集成于Lumaqq，如图(Pidgin也有)

旅程开始了。。。祝贺您一路顺风。。。。

不说废话了，看代码把 转载请注明出处，谢谢了！

Luma写的 我翻译的

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;

namespace CrazyCoder.QQ
{



    public class Crypter
    {

        // 指向当前的明文块
        private byte[] plain;
        // 这指向前面一个明文块
        private byte[] prePlain;
        // 输出的密文或者明文
        private byte[] outData;
        // 当前加密的密文位置和上一次加密的密文块位置，他们相差8
        private int crypt, preCrypt;
        // 当前处理的加密解密块的位置
        private int pos;
        // 填充数
        private int padding;
        // 密钥
        private byte[] key;
        private bool header = true;
        private int contextStart;
        private static byte rand = 0x0;




        public byte[] encrypt(byte[] inData, int offset, int len, byte[] key)
        {
            plain = new byte[8];
            prePlain = new byte[8];
            pos = 1;
            padding = 0;
            crypt = preCrypt = 0;
            this.key = key;
            header = true;

            // 计算头部填充字节数
            pos = (len + 0x0A) % 8;
            if (pos != 0)
                pos = 8 - pos;
            // 计算输出的密文长度
            outData = new byte[len + pos + 10];
            // 这里的操作把pos存到了plain的第一个字节里面
            //     0xF8后面三位是空的，正好留给pos，因为pos是0到7的值，表示文本开始的字节位置
            plain[0] = (byte)((rand & 0xF8) | pos);

            // 这里用随机产生的数填充plain[1]到plain[pos]之间的内容
            for (int i = 1; i <= pos; i++)
                plain[i] = (byte)(rand & 0xFF);
            pos++;
            // 这个就是prePlain，第一个8字节块当然没有prePlain，所以我们做一个全0的给第一个8字节块 傲博知识库
            for (int i = 0; i < 8; i++)
                prePlain[i] = (byte)(0x0);

            // 继续填充2个字节的随机数，这个过程中如果满了8字节就加密之 疯狂代码
            padding = 1;
            while (padding <= 2)
            {
                if (pos < 8)
                {
                    plain[pos++] = (byte)(rand & 0xFF);
                    padding++;
                }
                if (pos == 8)
                    encrypt8Bytes();
            }

            // 头部填充完了，这里开始填真正的明文了，也是满了8字节就加密，一直到明文读完
            int i2 = offset;
            while (len > 0)
            {
                if (pos < 8)
                {
                    plain[pos++] = inData[i2++];
                    len--;
                }
                if (pos == 8)
                    encrypt8Bytes();
            }

            // 最后填上0，以保证是8字节的倍数
            padding = 1;
            while (padding <= 7)
            {
                if (pos < 8)
                {
                    plain[pos++] = (byte)(0x0);
                    padding++;
                }
                if (pos == 8)
                    encrypt8Bytes();
            }

            return outData;
        }


        private void encrypt8Bytes()
        {

            for (pos = 0; pos < 8; pos++)
            {
                if (header)
                    plain[pos] ^= prePlain[pos];
                else
                    plain[pos] ^= outData[preCrypt + pos];
            }

            byte[] crypted = encipher(plain);
            Array.Copy(crypted, 0, outData, crypt, 8);

            for (pos = 0; pos < 8; pos++)
                outData[crypt + pos] ^= prePlain[pos];
            Array.Copy(plain, 0, prePlain, 0, 8);
            preCrypt = crypt;
            crypt += 8;
            pos = 0;
            header = false;
        }


        public byte[] encrypt(byte[] inData, byte[] key)
        {
            return encrypt(inData, 0, inData.Length, key);
        }


        private byte[] encipher(byte[] inData)
        {

            int loop = 0x10;
            uint y2 = BitConverter.ToUInt32(inData, 0);
            uint y =(uint)(IPAddress .NetworkToHostOrder ( y2)>>32);

            uint z2 = BitConverter.ToUInt32(inData, 4);
            uint z = (uint)(IPAddress.NetworkToHostOrder(z2) >> 32);


            uint a2 = BitConverter.ToUInt32(key, 0);
            uint a = (uint)(IPAddress.NetworkToHostOrder(a2) >> 32);
            uint b2 = BitConverter.ToUInt32(key, 4);
            uint b = (uint)(IPAddress.NetworkToHostOrder(b2) >> 32);
            uint c2 = BitConverter.ToUInt32(key, 8);
            uint c = (uint)(IPAddress.NetworkToHostOrder(c2) >> 32);
            uint d2 = BitConverter.ToUInt32(key, 12);
            uint d = (uint)(IPAddress.NetworkToHostOrder(d2) >> 32);
            uint sum = 0;
            uint delta = 0x9E3779B9;
            while (loop-- > 0)
            {
                sum += delta;

                y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);

                z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);

            }


            byte[] ret = new byte[8];
            ret[3] = (byte)y;
            ret[2] = (byte)(y >> 8);
            ret[1] = (byte)(y >> 16);
            ret[0] = (byte)(y >> 24);
            ret[7] = (byte)z;
            ret[6] = (byte)(z >> 8);
            ret[5] = (byte)(z >> 16);
            ret[4] = (byte)(z >> 24);
            return ret;

        }

        public byte[] decrypt(byte[] inData, int offset, int len, byte[] key)
        
        {
            crypt = preCrypt = 0;
            this.key = key;
            int count;
            byte[] m = new byte[offset + 8];


            if ((len % 8 != 0) &#124;&#124; (len < 16))
                return null;
      
            prePlain = decipher(inData, offset);
            pos = prePlain[0] & 0x7;
            // 得到真正明文的长度
            count = len - pos - 10;
            // 如果明文长度小于0，那肯定是出错了，比如传输错误之类的，返回
            if (count < 0)
                return null;

            // 这个是临时的preCrypt，和加密时第一个8字节块没有prePlain一样，解密时
            //     第一个8字节块也没有preCrypt，所有这里建一个全0的
            for (int i = offset; i < m.Length; i++)
                m[i] = 0;
            // 通过了上面的代码，密文应该是没有问题了，我们分配输出缓冲区
            outData = new byte[count];
            // 设置preCrypt的位置等于0，注意目前的preCrypt位置是指向m的，因为Java没有指针，所以我们在后面要控制当前密文buf的引用
            preCrypt = 0;
            // 当前的密文位置，为什么是8不是0呢？注意前面我们已经解密了头部信息了，现在当然该8了
            crypt = 8;
            // 自然这个也是8
            contextStart = 8;
            // 加1，和加密算法是对应的
            pos++;

            // 开始跳过头部，如果在这个过程中满了8字节，则解密下一块
            // 因为是解密下一块，所以我们有一个语句 m = in，下一块当然有preCrypt了，我们不再用m了
            // 但是如果不满8，这说明了什么？说明了头8个字节的密文是包含了明文信息的，当然还是要用m把明文弄出来
            // 所以，很显然，满了8的话，说明了头8个字节的密文除了一个长度信息有用之外，其他都是无用的填充
            padding = 1;
            while (padding <= 2)
            {
                if (pos < 8)
                {
                    pos++;
                    padding++;
                }
                if (pos == 8)
                {
                    m = inData;
                    if (!decrypt8Bytes(inData, offset, len))
                        return null;
                }
            }

            // 这里是解密的重要阶段，这个时候头部的填充都已经跳过了，开始解密
            // 注意如果上面一个while没有满8，这里第一个if里面用的就是原始的m，否则这个m就是in了
            int i2 = 0;
            while (count != 0)
            {
                if (pos < 8)
                {
                    outData[i2] = (byte)(m[offset + preCrypt + pos] ^ prePlain[pos]);
                    i2++;
                    count--;
                    pos++;
                }
                if (pos == 8)
                {
                    m = inData;
                    preCrypt = crypt - 8;
                    if (!decrypt8Bytes(inData, offset, len))
                        return null;
                }
            }

            // 最后的解密部分，上面一个while已经把明文都解出来了，到了这里还剩下什么？对了，还剩下尾部的填充，应该全是0
            // 所以这里有检查是否解密了之后是0，如果不是的话那肯定出错了，所以返回null
            for (padding = 1; padding < 8; padding++)
            {
                if (pos < 8)
                {
                    if ((m[offset + preCrypt + pos] ^ prePlain[pos]) != 0)
                        return null;
                    pos++;
                }
                if (pos == 8)
                {
                    m = inData;
                    preCrypt = crypt;
                    if (!decrypt8Bytes(inData, offset, len))
                        return null;
                }
            }
            return outData;
        }


        private bool decrypt8Bytes(byte[] inData, int offset, int len)
        {
            // 这里第一步就是判断后面还有没有数据，没有就返回，如果有，就执行 crypt ^ prePlain
            for (pos = 0; pos < 8; pos++)
            {
                if (contextStart + pos >= len)
                    return true;
                prePlain[pos] ^= inData[offset + crypt + pos];
            }

            // 好，这里执行到了 d(crypt ^ prePlain)
            prePlain = decipher(prePlain);
            if (prePlain == null)
                return false;

            // 解密完成，wait，没完成哦，最后一步没做哦？
            // 这里最后一步放到decrypt里面去做了，因为解密的步骤毕竟还是不太一样嘛
            // 调整这些变量的值先
            contextStart += 8;
            crypt += 8;
            pos = 0;
            return true;
        }


        public byte[] decrypt(byte[] inData, byte[] key)
        {
            return decrypt(inData, 0, inData.Length, key);
        }


        private byte[] decipher(byte[] inData, int offset)
        {


            //int loop = 0x10;
            //uint y = BitConverter.ToUInt32(inData, 0);
            //uint z = BitConverter.ToUInt32(inData, 4);
            //uint a = BitConverter.ToUInt32(key, 0);
            //uint b = BitConverter.ToUInt32(key, 4);
            //uint c = BitConverter.ToUInt32(key, 8);
            //uint d = BitConverter.ToUInt32(key, 12);
            //uint sum = 0xE3779B90;
            //uint delta = 0x9E3779B9;
            int loop = 0x10;
            uint y2 = BitConverter.ToUInt32(inData, offset);
            uint y = (uint)(IPAddress.NetworkToHostOrder(y2) >> 32);

            uint z2 = BitConverter.ToUInt32(inData, offset+4);
            uint z = (uint)(IPAddress.NetworkToHostOrder(z2) >> 32);


            uint a2 = BitConverter.ToUInt32(key, 0);
            uint a = (uint)(IPAddress.NetworkToHostOrder(a2) >> 32);
            uint b2 = BitConverter.ToUInt32(key, 4);
            uint b = (uint)(IPAddress.NetworkToHostOrder(b2) >> 32);
            uint c2 = BitConverter.ToUInt32(key, 8);
            uint c = (uint)(IPAddress.NetworkToHostOrder(c2) >> 32);
            uint d2 = BitConverter.ToUInt32(key, 12);
            uint d = (uint)(IPAddress.NetworkToHostOrder(d2) >> 32);
            uint sum = 0xE3779B90;
            uint delta = 0x9E3779B9;



            while (loop-- > 0)
            {
                z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
                y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
                sum -= delta;
            }




            byte[] ret = new byte[8];
            ret[3] = (byte)y;
            ret[2] = (byte)(y >> 8);
            ret[1] = (byte)(y >> 16);
            ret[0] = (byte)(y >> 24);
            ret[7] = (byte)z;
            ret[6] = (byte)(z >> 8);
            ret[5] = (byte)(z >> 16);
            ret[4] = (byte)(z >> 24);

            return ret;





        }

        /// <summary> 解密
        /// by http://www.CrazyCoder.cn/
        /// </summary>
        /// <param name="">in
        /// 密文
        /// </param>
        /// <returns>
        /// 明文
        /// </returns>
        private byte[] decipher(byte[] inData)
        {
            return decipher(inData, 0);
        }





        /// <summary> 这是个随机因子产生器，用来填充头部的，如果为了调试，可以用一个固定值
        /// 随机因子可以使相同的明文每次加密出来的密文都不一样 比如傲博知识库类似的
        ///
        /// </summary>
        /// <returns>
        /// 随机因子
        /// </returns>

        static Crypter()
        {

        }
        //public static int urshift(uint number, int bits)
        //{

//by  www.CrazyCoder.cn
        //    if (number >= 0)
        //        return number >> bits;
        //    else
        //        return (number >> bits) + (uint)(2 << ~bits);
        //}


    }
}

QQ机器人源代码_CrazyCoder_CN.rar

分析QQ协议具体数据包，最简单的办法，是Http接口下手，于是把我以前写的Ajax给拆了，在把所谓的qq接口研究成果给鼓捣在一起，然后去 Webqq(http://Webqq.qq.com)上大抢一遍，那家伙，天昏地暗，相当的&(&(。
      代码我是用script写的：
                   异步Ajax会话类
  1//异步Ajax会话类
  2if(typeof(AjaxSession) == 'undefined')
  3var AjaxSession = function(){
  4    
  5    //创建会话
  6    this.CreateSession = function()
  7    {
  8        if (window.ActiveXObject){  // IE
  9            try{    
10                return new ActiveXObject('Microsoft.xmlHTTP');
11            }catch(e){}
12                
13            try{
14                return new ActiveXObject('Msxml2.xmlHTTP');
15            }catch(ee){}
16        }else{                   //Mozilla, Safari
17            var s = new xmlHttpRequest();
18            if (s.readyState == null) {
19                s.readyState = 1;
20                s.addEventListener("load", function () {
21                    s.readyState = 4;
22                    if (typeof(s.onreadystatechange) == "function")
23                        s.onreadystatechange();
24                }, false);
25            }
26            
27            return s;
28        }
29                    
30        return null;
31    }
32    
33    //进行请求
34    this.Request = function(url, params, callback)
35    {    
36        
37        var s = this.CreateSession();
38        if(null == s)
39            alert("对不起，您的浏览器不支持某些特性。");
40        else
41            s.abort();
42        
43        var isAsync =  typeof(callback) == 'function';
44        var method = !params ? "GET" : "POST";
45
46        if(isAsync) s.onreadystatechange = function()
47        {
48            try{
49                alert(s.status);
50                if ((4 == s.readyState) && (200 == s.status || 304 == s.status))
51                    callback(this.Response(s));
52                else
53                    alert("请求错误,错误原因：" + s.statusText);    
54            }catch(e){}
55        }
56                
57        s.open(method, url, isAsync);        
58        s.setRequestHeader("Connection","Keep-Alive");        
59        s.setRequestHeader("Content-Type","text/html; charset=gb2312");
60        //s.setRequestHeader("Content-Type","text/plain; charset=UTF-8");
61        
62        if(method == "POST")
63        {
64            s.setRequestHeader("Content-Length",params.length)
65            s.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
66            
67        }
68
69        alert(params);
70        s.send(params);
71        
72            
73        if(!isAsync)
74            return  this.Response(s);
75    }
76    
77    //返回应答信息 疯狂代码
78    this.Response = function(s)
79    {
80        if(s.status == 200  || 304 == s.status)
81        {
82            if(s.responsexml != null && s.responsexml.xml != null && s.responsexml.xml != '')
83                return s.responsexml;
84            else
85                return s.responseText;
86        }    
87    }
88    
89    //对字符串进行编码
90    this.UncCoding = function(s)
91    {
92        var utput = '';
93        for(var i = 0 ;i< s.length;i++){
94            output = output + '%' + s.charCodeAt(i);
95        }        
96
97        return output;
98    }
99
100    //获取xml结构 傲博知识库
101    this.GetDom = function(s){
102        var doc = new ActiveXObject('Microsoft.xmlDOM');
103        doc.async = false;
104        doc.loadxml(s) ;    
105        return doc;
106    }
107    
108    return this;
109}
//QQ会话类
1//会话类
2if(typeof(QQSession) == 'undefined')
3var QQSession = function(){
4    this.UIN = 0;
5    this.md5PasswordStr = "";
6    this.WebQQUrl = "http://tqq.tencent.com:8000/";
7    this.qs = null;    
8    this.isLogin = false;
9    this.SeqIndex = null;
10    
11    //用户登陆
12    this.Login = function(uin,passwd,vcode,qs){
13        var m5 = new md5();        
14        this.UIN = uin;        
15        this.md5PasswordStr = m5.calcmd5(passwd);
16        var CmdStr = "VER=1.0&CMD=1&SEQ=" + this.GetNewSEQ() + "&UIN=" + uin + "&PS=" + this.md5PasswordStr + "&STATUS=10&VCODE=" + vcode + "&QQSESSION=" + qs ;    
17        
18        //if(!this.qs)
19        //    this.qs = new AjaxSession();
20        window.frames["proxy"].request(this.WebQQUrl,CmdStr);
21        //this.qs.Request(this.WebQQUrl,CmdStr,this.ShowMsg);
22        
23        //document.getElementById("ssl_login").callback = this.ShowMsg;
24        //document.getElementById("ssl_login").src = "https://Webqq-proxy.qq.com/Webqq/l?"+ CmdStr;
25    }
26    
27    //用户信息
28    this.GetInfo = function(){
29        var CmdStr = "VER=1.0&CMD=10&SEQ=" + this.GetNewSEQ() + "&UIN=" + this.UIN + "&FUIN=" + this.UIN;
30        this.qs.Request(this.WebQQUrl,CmdStr,this.ShowMsg);    
31        //window.frames["proxy"].request(this.WebQQUrl,CmdStr);
32    }
33    
34    //获取好友列表
35    this.GetList = function(){
36        var CmdStr = "VER=1.0&CMD=2&SEQ=" + this.GetNewSEQ() + "&UIN=" + this.UIN + "&NPOS=0";
37        this.qs.Request(this.WebQQUrl,CmdStr,this.ShowMsg);    
38    }
39    
40    //获得新的SEQ CrazyCoder.cn
41    this.GetNewSEQ = function(){
42        if(!this.SeqIndex){
43            var d = new Date();
44            this.SeqIndex = d.getTime()
45        }
46        
47        this.SeqIndex ++;
48        return this.SeqIndex;        
49    }
50    
51    this.ShowMsg = function(s){
52        alert(s);
53    }
54    
55    return this;
56}
     我在那用天真的眼神，盼望着能从这个地方掏出点东西来。可偏偏我这个比较倒霉的孩子，碰到了极其复杂的网络问题（家穷人丑，只好用手机上网，速度回到上世纪90年代），掏了半天啥也没弄到，返回的尽是12152错误。
     去翻MSDN时，遇到几个头疼的单词（鄙人英语着实差劲，单词量屈指可数），很习惯的就去开金山词霸。等等，金山词霸能把别的窗口的信息给拽出来，为什么我就不能。于是我就抛弃了前面的工作，从QQ对话窗口下手。nndx，偶就不信了，偶还灭不了你。
  说干就干，那就先勾吧，.net好象是干不了这事,但是winapi还是能干这活的。win32编程嘛，不就几个消息循环（—（—……*（—
WinApi调用
  1using System;
  2using System.Drawing;
  3using System.Runtime.InteropServices;
  4
  5namespace TQQ
  6{
  7    /**//// <summary>
  8    /// WinApi调用
  9    /// </summary>
10    public class WinApi
11    {
12        /**//// <summary>
13        /// 根据鼠标位置获取窗体
14        /// </summary>
15        /// <param name="lpPoint"></param>
16        /// <returns></returns>
17        [DllImport("user32.dll")]
18        public static extern IntPtr WindowFromPoint(Point lpPoint);
19
20        /**//// <summary>
21        /// 获取鼠标位置
22        /// </summary>
23        /// <param name="lpPoint"></param>
24        /// <returns></returns>
25        [DllImport("user32.dll")]
26        public static extern int GetCursorPos(out Point lpPoint);
27
28        /**//// <summary>
29        /// 获取鼠标位置下的窗体
30        /// </summary>
31        /// <returns></returns>
32        public static IntPtr GetLocalWindow()
33        {
34            Point point;
35            GetCursorPos(out point);
36            return WindowFromPoint(point);
37        }
38
39        /**//// <summary>
40        /// 申请内存空间
41        /// </summary>
42        /// <param name="hProcess"></param>
43        /// <param name="lpAddress"></param>
44        /// <param name="dwSize"></param>
45        /// <param name="flAllocationType"></param>
46        /// <param name="flProtect"></param>
47        /// <returns></returns>
48        [ DllImport( "Kernel32.dll" )]
49        public static extern Int32 VirtualAllocEx(IntPtr hProcess,Int32 lpAddress,Int32 dwSize,Int16 flAllocationType,Int16 flProtect);
50
51        /**//// <summary>
52        /// 读取内存空间
53        /// </summary>
54        /// <param name="hProcess"></param>
55        /// <param name="lpBaseAddress"></param>
56        /// <param name="lpBuffer"></param>
57        /// <param name="nSize"></param>
58        /// <param name="lpNumberOfBytesWritten"></param>
59        /// <returns></returns>
60        [ DllImport( "Kernel32.dll" )]
61        public static extern int ReadProcessMemory(IntPtr hProcess, Int32 lpBaseAddress,byte[] lpBuffer,long nSize,long lpNumberOfBytesWritten);
62
63        /**//// <summary>
64        /// 写内存空间
65        /// </summary>
66        /// <param name="hProcess"></param>
67        /// <param name="lpBaseAddress"></param>
68        /// <param name="lpBuffer"></param>
69        /// <param name="nSize"></param>
70        /// <param name="lpNumberOfBytesWritten"></param>
71        /// <returns></returns>
72        [ DllImport( "Kernel32.dll" )]
73        public static extern int WriteProcessMemory(IntPtr hProcess, Int32 lpBaseAddress,byte[] lpBuffer,long nSize,long lpNumberOfBytesWritten);
74
75        /**//// <summary>
76        /// 根据类/标题查找窗口
77        /// </summary>
78        /// <param name="lpClassName"></param>
79        /// <param name="lpWindowName"></param>
80        /// <returns></returns>
81        [DllImport("User32.dll",EntryPoint="FindWindow")]
82        public static extern IntPtr FindWindow(string lpClassName,string lpWindowName);
83
84        /**//// <summary>
85        /// 获取窗口子对象
86        /// </summary>
87        /// <param name="hwndParent"></param>
88        /// <param name="hwndChildAfter"></param>
89        /// <param name="lpszClass"></param>
90        /// <param name="lpszWindow"></param>
91        /// <returns></returns>
92        [DllImport("user32.dll",EntryPoint="FindWindowEx")]
93        public static extern IntPtr FindWindowEx(IntPtr hwndParent,IntPtr hwndChildAfter, string lpszClass, string lpszWindow);
94
95        /**//// <summary>
96        /// 发送windows消息
97        /// </summary>
98        /// <param name="hWnd"></param>
99        /// <param name="Msg"></param>
100        /// <param name="wParam"></param>
101        /// <param name="lParam"></param>
102        /// <returns></returns>
103        [DllImport("User32.dll")]
104        public static extern IntPtr SendMessage(IntPtr hWnd,int Msg,IntPtr wParam,IntPtr lParam);
105
106        /**//// <summary>
107        /// 发送windows消息
108        /// </summary>
109        /// <param name="hWnd"></param>
110        /// <param name="Msg"></param>
111        /// <param name="wParam"></param>
112        /// <param name="lParam"></param>
113        /// <returns></returns>
114        [DllImport("User32.dll",EntryPoint="SendMessage")]
115        public static extern int SendMessage(IntPtr hWnd,int Msg, IntPtr wParam, string lParam);
116
117        /**//// <summary>
118        /// 发送windows消息
119        /// </summary>
120        /// <param name="hwnd"></param>
121        /// <param name="wMsg"></param>
122        /// <param name="wParam"></param>
123        /// <param name="lParam"></param>
124        /// <returns></returns>
125        [DllImport("user32.dll", CharSet = CharSet.Auto)]
126        public static extern int SendMessage( IntPtr hwnd, int wMsg, int wParam,string lParam);
127
128        /**//// <summary>
129        /// 发送windows消息
130        /// </summary>
131        /// <param name="hwnd"></param>
132        /// <param name="wMsg"></param>
133        /// <param name="wParam"></param>
134        /// <param name="lParam"></param>
135        /// <returns></returns>
136        [DllImport("user32.dll", CharSet = CharSet.Auto)]
137        public static extern int SendMessage( IntPtr hwnd, int wMsg, int wParam,int lParam);
138
139        /**//// <summary>
140        /// 发送windows消息
141        /// </summary>
142        /// <param name="hwnd"></param>
143        /// <param name="wMsg"></param>
144        /// <param name="wParam"></param>
145        /// <param name="lParam"></param>
146        /// <returns></returns>
147        [DllImport("user32.dll", CharSet = CharSet.Auto)]
148        public static extern int SendMessage( IntPtr hwnd, int wMsg, int wParam,System.Text.StringBuilder lParam);
149
150        public const int WM_GETTEXT = 0x000D;
151        public const int WM_GETTEXTLENGTH = 0x000E;
152        public const int WM_SETTEXT = 0x000C;
153        public const int WM_CLICK = 0x00F5;
154        public const int WM_CHAR = 0x0102;
155        public const int EM_SETSEL = 0x00B1;
156        public const int EM_REPLACESEL = 0x00C2;
157
158    }
159}QQ钩子
1/**//// <summary>
2    /// QQ钩子
3    /// </summary>
4    public class QQHooks
5    {
6        /**//// <summary>
7        /// 发送消息
8        /// </summary>
9        /// <param name="windowName">窗口标题</param>
10        /// <param name="strMsg">消息内容</param>
11        public static void SendMsg(string windowName,string strMsg)
12        {
13            string lpszParentClass = "#32770"; //整个窗口的类名
14            string lpszParentWindow = windowName; //窗口标题
15            IntPtr ip = WinApi.FindWindow(lpszParentClass,lpszParentWindow);    
16            IntPtr EdithParentWnd = WinApi.FindWindowEx(ip,new IntPtr(0),"#32770","");
17            IntPtr EdithWnd = WinApi.FindWindowEx(EdithParentWnd,new IntPtr(0),"AfxWnd42","");            
18
19            string lpszClass_Text = "RICHEDIT"; //消息输入窗口
20            string lpszName_Text = ""; //消息输入窗口
21            IntPtr THandle = WinApi.FindWindowEx(EdithWnd,new IntPtr(0),lpszClass_Text,lpszName_Text);
22            
23            StringBuilder sb = new StringBuilder(strMsg);
24            WinApi.SendMessage(THandle,WinApi.EM_SETSEL,-1,-1);//            
25            WinApi.SendMessage(THandle,WinApi.EM_REPLACESEL,0,sb);
26
27            string lpszClass_Submit = "Button"; //需要查找的Button的类名
28            string lpszName_Submit = "发送(&S)"; //需要查找的Button的标题
29            IntPtr TButtonHandle =  WinApi.FindWindowEx(EdithParentWnd,new IntPtr(0),lpszClass_Submit,lpszName_Submit);
30            WinApi.SendMessage(TButtonHandle,WinApi.WM_CLICK,new IntPtr(0),"");//发送消息到目标控件使它执行click事件
31        }
32
33        /**//// <summary>
34        /// 获取消息
35        /// </summary>
36        /// <param name="windowName">窗口标题</param>
37        /// <returns></returns>
38        public static string GetMsg(string windowName)
39        {
40            string lpszParentClass = "#32770"; //整个窗口的类名
41            string lpszParentWindow = windowName; //窗口标题
42            IntPtr ip = WinApi.FindWindow(lpszParentClass,lpszParentWindow);    
43            IntPtr EdithWnd = WinApi.FindWindowEx(ip,new IntPtr(0),"#32770","");
44
45            string lpszClass_Text = "RichEdit20A"; //查找历史记录类
46            string lpszName_Text = ""; //查找历史记录类的标题
47            IntPtr THandle = WinApi.FindWindowEx(EdithWnd,new IntPtr(0),lpszClass_Text,lpszName_Text);
48
49            StringBuilder sb = new StringBuilder(300000);
50            WinApi.SendMessage(THandle,WinApi.WM_GETTEXT,255,sb);//发送消息到目标控件        
51            WinApi.SendMessage(THandle,WinApi.WM_SETTEXT,0,"");
52            return sb.ToString();
53        }
54    }

东西到手了，传话筒的工作基本上算是完成了，接下来就让它显示出来：
1    /**//// <summary>
2        /// 时钟事件
3        /// </summary>
4        /// <param name="sender"></param>
5        /// <param name="e"></param>
6        private void tmGetMsg_Tick(object sender, System.EventArgs e)
7        {
8            //群1里的消息
9            string strMsg = QQHooks.GetMsg(txtGroupWinName1.Text);        
10            string str = "";
11            
12            if(!string.Empty.Equals(strMsg))
13            {
14                ArrayList msgList = ParseMsg.Parse(strMsg);
15
16                foreach(QQMsg msg in msgList)
17                {
18                    if("253822559" == msg.Number.ToString())continue;
19                    
20                    if(string.Empty.Equals(msg.Msg.Trim()))
21                        str =  string.Format("{0}在群1里做了个表情\r\n",msg.Name,msg.Msg);
22                    else
23                         str =  string.Format("{0}在群1里说:\r\n{1}\r\n",msg.Name,msg.Msg);
24                    
25                    lbGroupMsgList1.Items.Add(str);
26                    //save msg
27                    
28                    //发送消息
29                    QQHooks.SendMsg(txtGroupWinName2.Text,str);
30                    QQHooks.SendMsg(txtGroupWinName3.Text,str);
31                    
32                }                
33            }
34  }
这里的txtGroupWinName1是让输入qq窗口标题。以前用asm32做程序的时候就觉的微软够BT的，要是每个窗口编译的时候就给限制个GUID多好—（）—＊）（（—
至此大功算是告成了，完美交差。拿着这东东，改天狠狠的宰我师兄几顿.

（07-01-04）续：
要的人太多了,我还是主动把东西传上来吧，要不然有骗 email地址之嫌
源代码和相关资料下载：/Files/sukyboor/Q.rar

附，说明：先介绍一下http方法：
1，qq接口.txt
   是我在网络上找的一篇“C#编写QQ接口软件--QQ协议篇” 里面有QQhttp协议访问的详细的介绍，协议标准是v1.1。但是经过我是没调通,好象是http://tqq.tencent.com:8000被封了，你有没有好的运气我就不知道了。tx的Webqq用的端口是http://Webqq-proxy.qq.com:8080/这个就是慢点，用还是能用的。
2,Maxthon_Appin 文件夹下面有2个文件QQTest.txt ，GetQQSession.txt。maxthon有个简易收集面板你可以动态的去调试脚本.用maxthon打开http://Webqq.qq.com后装入qqtest.txt你会发现访问过程的一举一动都在你的监视之中。Log.txt就是这么来的。GetQQSession.txt操作同上，用于获取一个新的sessionid
3,log.txt是监视http://Webqq.qq.com的访问过程后得来的.你可以参考qq接口.txt看。不过tx的Webqq用的是v1.0的接口，但大体上是相似的，相信聪明的你是可以看懂的。
  4,Webqq文件夹下放着http://Webqq.qq.com被我下到本地的页面。有兴趣的可以去看看里面的脚本，尤其是js\Web_cmd.js虽然写的比我还烂，但还是值得一看。
5,WQQ文件夹下放着我写的测试页面。不过我家的破电脑调不通。如果你运气好的话，在这个基础上继续干吧。不过别忘记了,到时候把做好的东西发给我一份(sukyboor·163.com)。
好了，下面说说钩子方法
  项目在TQQ文件夹下面,注释写的挺详细的，自己看吧。
就提醒4点，
1 是app.config里面的qqnum一定要配置成你的qq号，否则你就等着别人骂你sx吧。
2 主窗口上的几个输入框一定要配置成群聊窗口的标题，否则它啥也干不了
3 别告诉我你还用qq2005
4 消息被转发以后在窗口里是看不到的，得点聊天记录按纽以后才能看的见

license.txt
  里面堆的是一堆套话,有空就瞅2眼.

QQ协议老变，为了分析协议，单用抓包工具还是不够的，还是得需要很好的调试工具。在网上找了几个调试工具，易用性均欠佳，不得已自己开发了一个 QQDebugger，不敢专美，特意发布出来。

QQDebugger 在功能上同 Red_angelX（http://blog.csdn.net/Red_angelX/）的 QQ_Debugger（http://blog.csdn.net/Red_angelX/archive/2006/09/14 /1221914.aspx）样，在易用性上有很大的改进，非常贴和 Ethereal 抓包结果，运行需要 .Net Framework 2.0。

下面以一个简单的QQ协议包分析为例，演示 QQDebugger 的使用：

(1) 抓包


 

（2）把欲分析的包 复制到 任意一个文本编辑器中，本例中的包如下：

了解QQ协议的知道，这里红线部分是 这个包中 TEA加密的密钥，绿线部分是 TEA 加密后的密文。

要知道明文，只需要从文本编辑器中，将密钥和密文分别复制到 QQDebugger 的响应对话框中（不需要清理文本格式！ QQDebugger 会自动清理文本）：



（3）点解密，可得到明文，这时候密钥和密文也自动本清理成整齐的字符串：



说明:

(1) QQDebugger 中使用了 Red_angelX 撰写的C# 版 加解密算法(http://blog.csdn.net/Red_angelX/archive/2006/09.aspx)。
(2) 欲了解QQ协议，可看 lumaqq 的协议文档（google 吧），Red_angelX 的博客上有对 QQ2006 Beta3 的协议登录部分的分析。

转自博客园xiaotie的博客 傲博知识库

4、获得QQ名单。
如果您加了您的好友，那么您的好友就会放入你的QQ的好友名单里面，那么我们要得到QQ名单就必需给QQ服务器发送得到好友名单的协议（我就不从复已知的参数了）：

VER=1.1&CMD=List&SEQ=&UIN=&TN=160&UN=0

服务器得到协议后如果成功则返回：

VER=1.1&CMD=LIST&SEQ=43661&UIN=29501213&RES=0&FN=1&SN=24&UN=561256,1943497,....

UN后面则是您好友的QQ号码，每个号码都由,进行分开。那么我们只需要得到UN后面的代码，把它列表化就OK了。C#可以用string.Split(',')把值放入列表进行处理，而DELPHI可以使用Split()把数值放入TStrings里进行处理。

5、获得QQ好友在线名单
获得QQ好友在线名单，跟获得好友名单差不多，唯一不同的是用的命令不同用的是Query_Stat，协议如下：

VER=1.1&CMD=Query_Stat&SEQ=&UIN=&TN=50&UN=0

服务器得到协议后如果成功则返回：

VER=1.1&CMD=QUERY_STAT&SEQ=-1&UIN=29501213&RES=0&FC=141,270,270,&FN=1&SN=3&ST=10,10,10,&UN=12327207,24259132,29501213,&NK= □,微程,鶹鸑,&

FC为QQ头像的的ID，如的头像ID为270，那么其头使用的图片为91.bmp,其算法为 ID/3+1。ST为QQ用户的状态，10为上线，20为离线，30为忙碌。UN为在线用户的QQ号，NK为在线用户的QQ昵称。ST，UN，NK，每个 逗号隔开的数据相互对应。在得到消息后如果用的是DELPHI语言，那么要用Utf8ToAnsi()进行转换，不然会出现乱码。

6、得到QQ用户的信息。
如果要看到QQ用户的真实名称，MAIL，年龄，个人说明等信息，那么我们必需要向服务器发送得到好友信息的信息：

VER=1.1&CMD=GetInfo&SEQ=&UIN=&LV=2&UN=

UN为要查看用户信息的QQ号。

服务器得到协议后如果成功则返回：

VER=1.1& amp;CMD=GETINFO&SEQ=12707&UIN=415103947&RES=0&AD=云南昆明& amp;AG=0&EM=Microprogramer@hotmail.com&FC=270&HP=msger.org(建 设中...)&JB=程序员&LV=2&PC=650000&PH=0871-6466529&PR=网络为 媒%252c关系为本%252c信息为财%252c客户为主.%0d%0a&PV=云南省&RN=刘X&SC=社会大学& amp;SX=0&UN=24259132&NK=微程

AD用户的联系地址，AG为用户年龄，EM为用户MAIL，FC 为用户头像，HP为用户网站，JB为用户职业，PC为用户邮编，PH为用户联系电话，PR为用户简介，PV为用户所以的省，RN为用户真实名称，SC为用 户毕业院校，SX为用户性别，UN为用户QQ号，NK为用户QQ昵称。在得到消息后如果用的是DELPHI语言，那么要用Utf8ToAnsi()进行转 换，不然会出现乱码

7、增加QQ好友。
想要新增好友，就要发送AddToList命令给服务器，具体命令如下：

VER=1.1&CMD=AddToList&SEQ=&UIN=&UN=

UN为我们要增加用户的QQ号。

服务器得到协议后如果成功则返回：

VER=1.1&CMD=AddToList&SEQ=13666&UIN=415103947&RES=0&CD=0&UN=24259132

CD 为被加QQ的身份验证状态，CD为0表示“允许任何人把我列为好友”，CD为1表示“需要身份证认才能把我列为好友”，CD为3表示“不允许任何人把我列 为好友”。如果CD为0那么信息回馈后，用户就直接加为好友了，如果CD为1，那么还要发送一次回应加为好友的响应。

8、回应加为好友的响应。

回应加为好友响应是双方的：1、如果你发送了请求加对方为好友，如果对方需要验证，那么必需发送回应加为好友的响应。2、如果对方发送加为好友请求给你，那么你可以加应加为好友的响应，一是加为好友，一是通过验证，一是拒决加为好友。我们要向服务器发送命令：

VER=1.1&CMD=Ack_AddToList&SEQ=&UIN=&UN=&CD=&RS=

CD为响应状态，CD为0表示“通过验证”。CD为1表示“拒决加为对方为好友”。CD为2表示“为请求对方加为好友”。RS为你要请求的理由，如果您用的是DELPHI那么RS在发送之间要用AnsiToUtf8()进行转换，不然发送过后，请求理由会变成“？”。

服务器得到协议后如果成功则返回：

VER=1.1&CMD=Ack_AddToList&SEQ=1130&UIN=415103947&RES=0&

9、删除好友。

删除好友其实很容易，向服务器发送DelFromList命令则可以删除用户：

VER=1.1&CMD=DelFromList&SEQ=&UIN=&UN=

UN为要删除用户的QQ号。

服务器得到协议后如果成功则返回：

VER=1.1&CMD=DelFromList&SEQ=24514&UIN=415103947&RES=0&

10、改变用户当前状态。
可以把QQ设置为在线，隐身等状态，我们可以发送Change_Stat给服务器以改变当前状态，具体命令如下：

VER=1.1&CMD=Change_Stat&SEQ=&UIN=&ST=

ST为要改变的状态，10为上线，20为离线，30为忙碌。傲博知识库

服务器得到协议后如果成功则返回：

VER=1.1&CMD=Change_Stat&SEQ=17512&UIN=415103947&RES=0&

11、退出登录
要退出登录，要向服务器发送命令Logout，具体命令如下：

VER=1.1&CMD=Logout&SEQ=&UIN=

服务器得到协议后如果成功则返回：

VER=1.1&CMD=LOGOUT&SEQ=15803&UIN=415103947&RES=0

12、获得好友QQ的消息

如果要接收好友的消息，要向服务器发送命令GetMsgEx，具体命令如下：

VER=1.1&CMD=GetMsgEx&SEQ=&UIN=

服务器得到协议后如果成功则返回：

VER=1.1&CMD=GETMSGEX&SEQ=56661&UIN=29501213&RES=0&MN=3&MT=99,9,9,&UN=24259132,24259132,24259132,&MG=30 ,asdfasdfasdfasdf ,asdfasdfasdf ,&

MT表示消息类型，99表示系统消息，9表示用户消息。 UN表示消息发送来源用户，MG表示发送的消息，MG消息可以表示某些特定的系统含意，譬如：当MT为99，MG为30，UN为24259132则表示用 户4259132现在处于忙碌状态，可根据此消息进行好友列表的刷新，提高效率。在得到消息后如果用的是DELPHI语言，那么要用 Utf8ToAnsi()进行转换，不然会出现乱码。

13、向好友QQ发送消息

要发送消息给好友，要向服务器发送命令CLTMSG命令，具体命令如下：

VER=1.1&CMD=CLTMSG&SEQ=&UIN=&UN=&MG=

UN为消息发送给的用户QQ号码，MG为发送给该用户的消息。如果您用的是DELPHI那么MG在发送之间要用AnsiToUtf8()进行转换，不然发送过后，消息会变成“？”。

服务器得到协议后如果成功则返回：

VER=1.1&CMD=CLTMSG&SEQ=15803&UIN=415103947&RES=0

好了，以上就是QQ基于HTTP的一个不完全的协议分析，在无源码前提下，在下能力有限，只能够分析这么多了。利用以上协议您就可以实现很多东西，如：QQ机器人，QQ广告系统，即时通讯的整合工具等等。

 
补充：

返回的系统消息参数的意义

20 对方登陆QQ

30 对方忙碌

41 对方希望通过验证

转载，很久以前的文章了，
仅供参考，
看到微程朋友分析基于http的QQ协议，于是准备写一个QQ程序。原以为有些包不能用了，后来灰衣人朋友的帮助下，才知道http通讯需要打开一次，关闭一次的。而不能象socket样，一直打开不关闭。

感谢微程和灰衣人朋友的帮助。关于协议大家可以看他的blog

http://spaces.msn.com/members/mprogramer/Blog/cns!1pKnbff3FpJuGZcrsAlNZmZQ!147.entry

本程序为MIT授权

如果需要转载本程序，请保留版权信息"""

import urllib,httplib,md5,time

class qq:

    def __init__(self,qq="",pwd=""):

        self.pwd=md5.new(pwd).hexdigest()

        self.headers=""

        self.qq=qq

        



    def getdata(self):

        self.conn= httplib.HTTPConnection("tqq.tencent.com:8000")#这里是tqq.tencent.com的ip地址，也可以直接用域名

        self.conn.request("POST","", self.headers)

        response = self.conn.getresponse()                                      

        print response.read().decode('utf-8').encode("cp936")

        self.conn.close



    def Login(self):#登陆

        self.headers=("VER=1.0&CMD=Login&SEQ="+\

                      str(int(time.time()*100)%(10**5))+"&UIN="+\

                      self.qq+"&PS="+\

                      self.pwd+\

                      "&M5=1&LC=9326B87B234E7235")

        self.getdata()      

        

        

    def Query_Stat(self):#在线好友

        self.headers=("VER=1.0&CMD=Query_Stat&SEQ="+\

                      str(int(time.time()*100)%(10**5))+"&UIN="+\

                      self.qq+"&TN=50&UN=0")

                      

        self.getdata() 

        

    def List(self):#好友列表

        self.headers=("VER=1.0&CMD=List&SEQ="+\

                      str(int(time.time()*100)%(10**5))+"&UIN="+\

                      self.qq+"&TN=160&UN=0")

        

        self.getdata()



    def GetInfo(self,friend=""):#指定QQ号码的详细内容

        self.headers=("VER=1.0&CMD=GetInfo&SEQ="+\

                      str(int(time.time()*100)%(10**5))+"&UIN="+\

                      self.qq+"&LV=2&UN="+\

                      friend)

        

        self.getdata() 



    def AddToList(self,friend=""):#增加指定QQ号码为好友

        self.headers=("VER=1.0&CMD=AddToList&SEQ="+\

                      str(int(time.time()*100)%(10**5))+"&UIN="+\

                      self.qq+"&UN="+\

                      friend)

        

        self.getdata()



    def GetMsg(self):#获取消息

        self.headers=("VER=1.0&CMD=GetMsgEx&SEQ="+\

                      str(int(time.time()*100)%(10**5))+"&UIN="+\

                      self.qq)

        

        self.getdata()



    def SendMsg(self,friend="",msg=""):#发送消息

        self.headers=("VER=1.0&CMD=CLTMSG&SEQ="+\

                      str(int(time.time()*100)%(10**5))+"&UIN="+\

                      self.qq+"&UN="+\

                      friend+"&MG="+\

                      msg.decode("cp936").encode('utf-8'))

        

        self.getdata()



    def Logout(self):#退出登陆

        self.headers=("VER=1.0&CMD=Logout&SEQ="+\

                      str(int(time.time()*100)%(10**5))+"&UIN="+\

                      self.qq)

        

        self.getdata()



test=qq('号码','密码')

test.Login()

test.Query_Stat()

test.List()

test.GetInfo('他人QQ号码')

test.AddToList('他人QQ号码')

test.GetMsg()

i=0

while i<1000:

    print i

    time.sleep(0.9)

    test.SendMsg('他人QQ号码',"一共有1000条消息，这是第"+str(i)+"条消息")

    i = i+1

test.Logout()

CQQUser存储一个QQ用户的所有信息，包括客户指定信息（用户名，密码 等）和服务器返回信息（指在和服务器通讯过程中服务器“设置的”信息，如各种各样的密钥是在和服务器通讯过程中某些特定步骤由服务器生成并返回的，而还有 些信息如服务器IP和端口则是最初由客户指定，但有可能因为服务器重定向而改变，等等等等）

CInPacket和COutPacket是 发送/接收包基类，CBasicInPacket/CBasicOutPacket是QQ基本协议族发送/接收包基 类，CBasicFamilyParser是QQ基本协议族消息管理器，至于要和QQ服务器正常通讯，还要用“翻译”成QQ服务器的“语言”——由 CCrypter加密/解密包

最后，所有类使用的常量则实现为类QQ的公共静态成员变量

而所有这些类都是为 CQQClient类服务的，它是QQProtocol的操作接口（数据接口则是CQQUser）。目前实现的版本主要接口是Login，负责向QQ服务 器登录。由它负责创建一个工作线程，向服务器发包，等待回复，回复的结果调用CQQClient的虚函数，所以对于库的使用者，需要生成一个派生类实现这 些虚函数以处理回复。

至此，很多朋友关心的demo也可以实现一个最简单的版本了，目前的demo是个命令行程序，使用UDP方式登录，已经测试成功。

代码SVN：

例子SVN：

引用请注明出处，谢谢

登录和登录回复包是用登录密钥加密/解密的

登录包构造（CLoginPacket::PutBody）和登录回复解析（CLoginReplyPacket::ParseBody）的每一步在源代码中注释都有说明，其中着重注意：

登录包构造中：没什么好说的，看代码

登录回复包解析中：

很 多请况下不会直接登录成功，而是由服务器返回一个登录重定向包（回复码是QQ.QQ_REPLY_LOGIN_REDIRECT），而且不止一次重定向服 务器，所谓重定向即——你向一个QQ服务器发送登录请求，而这个服务器会告诉你另一个QQ服务器地址和端口（不要告诉我你认为腾讯只有一个服务器

），这时你就要向后者重发登录包（但是登录密钥都是一样的）。至于为什么不直接在这个服务器登录，这你就要问腾讯的客服了（取决于服务器的策略）

如果登录失败，会返回失败消息的字符串

最后就是登陆成功的消息，登录成功会返回很多重要信息，包括你想到的和没想到的，其中session key（会话密钥）是下一个密钥，你今后发送的大多数消息和接收的大多数消息，都是用这个密钥加密解密的

代码SVN：

引用请注明出处，谢谢

代码SVN：

引用请注明出处，谢谢

QQ基本协议族的接受包基类是CBasicInPacket，发送包基类是CBasicOutPacket，分别从接受/发送包基类CInPacket和COutPacket派生而来

CBasicOutPacket 把COutPacket的m_bHeader置为QQ.QQ_HEADER_BASIC_FAMILY，实现了COutPacket的纯虚函数 PutHeader和PutTail；CBasicInPacket实现了CInPacket的纯虚函数ParseHeader和ParseTail。也 就是说基本协议族的包头和包尾有相同的结构，可以看一下接本协议族的包头结构和包尾结构

代码SVN：

引用请注明出处，谢谢

QQ协议中，不管是接收包还是发送包，在应用层都分为三个部分：

包头，包括协议类型，源QQ版本号，命令号，和包序列号，发送包还有一个需要/不需要ack标志

包体和包尾，其中包体是需要加密解密的部分，以后再介绍

值得注意的是，QQ号码和密码等等都是在包体即需要加密解密的部分中，但包头中包含的东西非常重要，它包括：

QQ协议类型，如QQ基本协议族用的是QQ::QQ_HEADER_BASIC_FAMILY(CInPacket/COutPacket的m_bHeader)

源 QQ版本号，在发IM包（即和其它QQ号通讯）中，在包体也会设置一次，但和QQ系统通讯时，这个源QQ版本号就是这个协议库使用的版本号，现在是 QQ::QQ_CLIENT_VERSION_0E1B，即QQ2005的版本号(CInPacket/COutPacket的m_sSource)

命令号，这个就很多了，每个CInPacket/COutPacket派生类会设置这个值(CInPacket/COutPacket的m_sCommand)

包序列号，QQ用它来防止丢包，这个只是发IM包时用到，包序列过程以后介绍(CInPacket/COutPacket的m_sSequence)

代码SVN：

引用请注明出处，谢谢

代码SVN：

引用请注明出处，谢谢

先贴出来QQ协议常量，基本上就是lumaqq完全移植的啦，所有协议常量都实现为类QQ的公共静态成员，给协议库中其它类使用，这么做完全是移植起来方便

class QQ

{

public:

      ...

};

CQQUser类：一个QQ用户的封装，如果一个QQ号码要登录，先要生成一个CQQUser对象，并进行设置

主要函数：

构造函数CQQUser 构造一个CQQUser对象时指定QQ号码和密码

SetServerIP 设置处理这个QQ用户的服务器，如sz.tencent.com

SetServerPort 端口，sz.tencent.com的端口是8000

SetHiddenLogin (是否)隐身登录

代码SVN：

QQ的版本升级比较频繁，而且与多数的软件不同的是，它客户端的升级往往伴随着协议相应的改变。

目前，对研究QQ协议版本比较重要的是：

QQ2000c 。它对应的客户端协议版本是08xx，目前对这个版本的研究比较多。

QQ2003 (0808) 这是腾讯最新公布的QQ版本，目前发现它对应的客户端协议版本是0A 1D。目前对这个版本的研究才刚刚开始，此版本对协议做了比较大的改动。

协议类型：

我们尝试把QQ的协议进行分类：

文字聊天协议族（TCPF, Text Chatting Protocol Family)：它主要支持与其它QQ客户端进行文字聊天。TCPF是建立在UDP协议之上。UDP数据包中的第一个字符02为这个协议族的标识。 TCPF的服务器使用8000号端口，腾讯的QQ客户端软件一般从4000号端口开始尝试使用，但实际上，对客户端使用的端口号并没有限制。目前的研究集 中在TCPF上。

其它未知可能存在的协议族：

我们观察到QQ除了与TCPF服务器通信以外，还有与其它的服务器使用UDP进行通信。目前我们观察到的服务器为 218.17.217.111 : 8000。客户端使用与TCPF不同的端口。目前观察到的从客户端发出的包以06开头，而服务器返回的包则以01开头。目前其具体作用未知。我们注意到一 个有趣的现象是，如果选择离线后重新上线，那么在发出登录包之前，这个通讯已经开始。我们暂时把它命名为数据传输协议族（DTPF，Data Transfer Protocol Family）。最新的研究发现，它传递的是QQ Show的图片数据。

语音、视频聊天：目前还没有开始分析，尚未知道是使用UDP还是TCP协议。

聊天室：没有分析，应该是TCP协议。

随着对这些协议分析的开始，我们会给它们更精细的划分和恰当的命名。

TCPF:

TCPF是建立在UDP协议上的协议族，主要支持文字聊天功能。TCPF是以请求－响应模式工作的。也就是说，客户端发出一个请求，服务器端会给出 一个相应的响应；服务器向客户端发送信息，客户端也会给服务器相应的响应。请求和响应通过相同的序列号来进行配对（请求代码也应该相同）。而且每种请求的 发起方都是相同的。目前，已知的请求包括：

0x0001  注销登录
0x0002  心跳信息
0x0004  更新用户信息
0x0005  搜索用户
0x0006  获取用户信息
0x0009  不需认证方式添加好友
0x000a  删除好友
0x000b  需要认证的方式添加好友
0x000d  设置隐身、示忙等状态
0x0012  确认收到系统消息
0x0016  发送消息
0x0017  收到消息（服务器发起）
0x001a  未知作用。
0x001c  在对方好友列表上删除自己
0x001d  未知作用。
0x0022  登录
0x0026  获取好友清单
0x0027  获取在线好友
0x0030  群操作指令
0x0080  收到系统消息（服务器发起）
0x0081  收到好友状态改变消息（服务器发起）

道理很简单的，如下：

通过FindWindow 获得QQ连连看的窗口handle，再捕捉QQ连连看的窗口，然后分释每个格的颜色，判断数据，然后存在一个two dimensional array里。这样程序就有了一份QQ连连看的数据了。

数据都有了，接下来就要找出两点之间是否能连得通。。这个算法也简单。先判断是否两点之间的位置，如果直线则只有一种连接的可能，比如两点的X相同，那么只能是上下的连接等。。

路茎的代码如下
程序代码
using System;
using System.Drawing;
using System.Windows.Forms;

namespace LianLianKan
{
/// <summary>
/// Summary description for FindPath.
/// This class is used to find a existing path of two point.
/// Author: DX,
/// email: Webmaster@51home.org
/// </summary>
public class FindPath
{
public FindPath()
{
}

#region GetTop() GetBottom, GetLeft, GetRight
private int GetTop(int [,] map, Point p)
{
if(p.X <= 0)
return 0;
else
{
for(int i=p.X-1; i>=0; i--)
if(map[i,p.Y] != 0)
return (i+1);
return 0;
}
}
private int GetBottom(int [,] map, Point p)
{
int maxLen = map.GetLength(0);
if(p.X >= maxLen )
return maxLen-1;
else
{
for(int i=p.X+1; i<maxLen; i++)
if( map[i, p.Y] != 0)
return (i-1);
return maxLen-1;
}
}
private int GetLeft(int [,] map, Point p)
{
if(p.Y <= 0)
return 0;
else
{
for(int i = p.Y-1; i>=0; i--)
if( map[p.X, i] != 0)
return (i+1);
return 0;
}
}
private int GetRight(int [,] map, Point p)
{
int maxLen = map.GetLength(1);
if(p.Y >= maxLen)
return maxLen-1;
else
{
for(int i=p.Y+1; i<maxLen; i++)
if(map[p.X, i] != 0)
return (i-1);
return maxLen-1;
}
}
#endregion

private bool CheckHorizontalPath(int [,] map, Rectangle r)
{
bool check;
for(int i= r.Y; i<= r.Y + r.Height; i++)
{
check = true;
for(int j=r.X + 1; j< r.X + r.Width; j++)
if( map[i,j] != 0 )
{
check = false;
break;
}

if(check)
{
// MessageBox.Show(string.Format("Rectangle x:{0}, y:{1}, Width:{2}, Height:{3}",r.X,r.Y,r.Width,r.Height));
return true;
}
}
return false;
}

private bool CheckVerticalPath(int [,] map, Rectangle r)
{
bool check;
for(int i = r.X; i<= r.X + r.Width; i++)
{
check = true;
for(int j = r.Y + 1; j < r.Y + r.Height; j++)
if(map[j,i] != 0)
{
check = false;
break;
}

if(check)
{
// MessageBox.Show(string.Format("Rectangle x:{0}, y:{1}, Width:{2}, Height:{3}",r.X,r.Y,r.Width,r.Height)); 傲博知识库
return true;
}
}
return false;
}

private bool HorizontalConnection(int [,] map, Point p1,Point p2)
{
int upper,lower;
int top1,top2,bottom1,bottom2;

top1 = GetTop(map,p1);
bottom1 = GetBottom(map, p1);

top2 = GetTop(map,p2);
bottom2 = GetBottom(map, p2);

upper = top1 > top2 ? top1 : top2;
lower = bottom1 < bottom2 ? bottom1 : bottom2;

if(upper > lower)
return false;
else
{
int x = p1.Y < p2.Y ? p1.Y : p2.Y;
Rectangle r = new Rectangle(x, upper, Math.Abs(p2.Y - p1.Y), lower - upper);

return CheckHorizontalPath(map,r);
}
}
private bool VerticalConnection(int [,] map, Point p1, Point p2)
{
int left, right;
int left1, left2, right1, right2;

left1 = GetLeft(map, p1);
right1 = GetRight(map, p1);
left2 = GetLeft(map,p2);
right2 = GetRight(map, p2);

left = left1 > left2 ? left1 : left2;
right = right1 < right2 ? right1 : right2;

if(left > right)
return false;
else
{
int y = p1.X < p2.X ? p1.X : p2.X;
Rectangle r = new Rectangle(left, y, right - left, Math.Abs(p1.X - p2.X));

return CheckVerticalPath(map, r);
}
}
public bool IsThereAPath(int [,] map, Point p1, Point p2)
{
if(p1.X == p2.X) // if two block is Vertical then only check vertical connection
return HorizontalConnection(map, p1, p2);
else if(p1.Y == p2.Y) // if two block on is horizontal, then only check for horizontal connection
return VerticalConnection(map, p1, p2);
else if( HorizontalConnection(map, p1, p2) ) // otherwise check for both
return true;
else
return VerticalConnection(map, p1, p2);
}
}
}

1、窗体引用两个timer控件，来控循环发送时间

2、调试环境 vs2005.net

程序代码
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Diagnostics;

namespace CrazyCoder.QQ.QQSendMessage
{
public partial class QQSendMessage : Form
{
[DllImport( "user32.dll ")]
static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
[DllImport( "user32.dll ")]
static extern IntPtr GetDlgItem(IntPtr hDlg, int nIDDlgItem);
[DllImport( "user32.dll ", SetLastError = true)]
public static extern IntPtr FindWindowEx(IntPtr parentHandle, int childAfter, string className, int windowTitle);
[DllImport( "user32.dll ", EntryPoint = "SendMessage ")]
static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, int wParam, string lParam);
[DllImport( "kernel32.dll ", CharSet = CharSet.Auto)]
public static extern IntPtr GetModuleHandle(string lpModuleName);

IntPtr hwndQQ;
IntPtr hwnd1;
IntPtr hwnd2;
IntPtr hwnd3;
IntPtr hwnd4;

public QQSendMessage()
{
InitializeComponent();
}

** void MySendMessage()
{
string machinename = System.Environment.MachineName;//获得计算机名
Process[] processlist = Process.GetProcesses(machinename);//得到所有进程
foreach (Process p in processlist)//列举每个进程
{
if (p.MainWindowTitle != " ")//标题是否为空，不为空执行下面代码
{
if (p.MainWindowTitle.ToString().Substring(0, 1) == "与 ")//查看窗口标题第一个字是否是“与”。如果是的，说明是QQ窗口
{
hwndQQ = FindWindow( "#32770 ", p.MainWindowTitle.ToString());
hwnd1 = GetDlgItem(hwndQQ, 0);
hwnd2 = GetDlgItem(hwnd1, 0);
hwnd3 = GetDlgItem(hwnd2, 894);
SendMessage(hwnd3, 194, 0, this.txtInput.Text);//向QQ输入框粘贴字符，this.textBox1.Text是要发送的文字信息
hwnd4 = GetDlgItem(hwnd1, 1);
SendMessage(hwnd4, 245, 0, Convert.ToString(0));
}
}
}
}

/// <summary>
/// 单个用户发送消息
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void btnSend_Click(object sender, EventArgs e)
{
MySendMessage();//发送信息,向单个用户发送。
}

/// <summary>
/// 循环发送消息
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void btnSSend_Click(object sender, EventArgs e)
{
this.Qtimer.Enabled = true;
}

/// <summary>
/// 停止发送消息
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void btnSStop_Click(object sender, EventArgs e)
{
this.Qtimer.Enabled = false;
}

/// <summary>
/// 计时器开始发送消息
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void Qtimer_Tick(object sender, EventArgs e)
{
this.MySendMessage();
}

** void QunSendMessage()//针对群的消息发送过程
{
string machinename = System.Environment.MachineName;
Process[] processlist = Process.GetProcesses(machinename);
foreach (Process p in processlist)
{
if (p.MainWindowTitle != " ")
{
if (p.MainWindowTitle.ToString().Substring(p.MainWindowTitle.Length - 1, 1) == "群 ")
{
hwndQQ = FindWindow( "#32770 ", p.MainWindowTitle.ToString());
hwnd1 = GetDlgItem(hwndQQ, 0);
hwnd2 = GetDlgItem(hwnd1, 0);
hwnd3 = GetDlgItem(hwnd2, 894);
SendMessage(hwnd3, 194, 0, this.txtGInput.Text);//向QQ输入框粘贴字符
hwnd4 = GetDlgItem(hwnd1, 1);
SendMessage(hwnd4, 245, 0, Convert.ToString(0));
}
}
}
}

/// <summary>
/// 向群组发消息
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void btnGXSend_Click(object sender, EventArgs e)
{
this.QunSendMessage();//向群发送单条信息
}

/// <summary>
/// 循环向群组发送消息
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void btnGSend_Click(object sender, EventArgs e)
{
this.QGtimer.Enabled = true;
}

/// <summary>
/// 停止向群组发送消息
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void btnGStop_Click(object sender, EventArgs e)
{
this.QGtimer.Enabled = false;
}

/// <summary>
/// 计时器发送消息
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void QGtimer_Tick(object sender, EventArgs e)
{
this.QunSendMessage();//连续发送信息，多少秒发送一次，自己设定。
}

/// <summary>
/// 利用tencent协议，打开临时对话框 
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void btnQQ_Click(object sender, EventArgs e)
{
string s = "tencent://message/?uin= " + this.txtQQ.Text + "&Site=im.qq.com&Menu=yes ";//是对方的QQ号 比如疯狂代码和傲博知识库的qq
Process.Start(s);
}

/// <summary>
/// 初始化窗体
/// </summary>
/// <param name= "sender "> </param>
/// <param name= "e "> </param>
** void QQSendMessage_Load(object sender, EventArgs e)
{
this.txtGms.Text = "1000 ";
this.txtMs.Text = "1000 ";
}

}
}

下面介绍一下具体的分析

1、找寻支持QQ HTTP协议的服务器。

很多人会认为QQ的HTTP服务器是基于80口进行通信的（如：218.17.209.23:80），其实不然，正真基于HTTP的服务器应该是：http://tqq.tencent.com:8000，它是一个通过8000口进行通讯的服务器。

由于QQ的HTTP服务器并不支持HTTP协议中GET方法，它支持POST方法。所以我们要给QQ的HTTP协议传参数，那么就必需要用POST方式才行。

2、C#和DELPHI是实现HTTP的POST方法的通信。

C#：

C#里System.Web空间下提供了一个叫做WebClient的对象，使用此对象就可以使C#直接对服务器发送Web客户端的请求。那么我们要对服 务器提交POST方法那么就必须使用其UploadData()方法才行。首先把要请求的信息先转换为字节（因为POST提交的是字符的流数据），然后再 做为UploadData()的参数。使用UploadData()进行数据提交，最后返回，POST的回馈信息。如下：

WebClient _client = new WebClient();

string postValues = "VER=1.0&CMD=Query_Stat&SEQ=12321&UIN=29501213&TN=50&UN=0";

Byte[] byteArray = System.Text.Encoding.ASCII.GetBytes(postValues);

Byte[] pageData = _client.UploadData(Host,"POST",byteArray);

这样，我们就利用C#进行了一次HTTP的POST方法提交了。

值在传入、返回时，其是基于UTF-8进行的，C#显示中文是很常.

3、实现QQ的用户登录。

在QQ通信中用户必需要登录后才可以进行互相发送信息等。QQ的登录是很关键的，大家所看到的用户在线，并不是用户的QQ一直连接着服务器，而是定时发送消信给服务器，证明自己还连着线，如果超出时间QQ就认为用户已经掉线了。

在登录协议中，QQ的密码是用标准的md5来进行加密，而C#自已带有，但是直接用不了，必需进行处理后，才能使其变成标准的md5，处理代码如下：

public static string md5(string toCryString)

{

md5CryptoServiceProvider hashmd5;

hashmd5 = new md5CryptoServiceProvider();

return BitConverter.ToString(hashmd5.ComputeHash(Encoding.Default.GetBytes(toCryString))).Replace("-","").ToLower();//asp 是小写,把所有字符变小写

}

傲博知识库

了解QQ是如何对用户密码加密后，那么我们就开始真正，解析QQ的HTTP登录协议了,我们把协议当传POST的参数传给服务器，而服务器则回馈相应的信息给客户端：

传入协议：

VER=1.1&CMD=Login&SEQ=&UIN=&PS=&M5=1&LC=9326B87B234E7235

VER是用来说明QQ协议的版本，CMD是说明协议的命令，Login就是指QQ的登录了，SEQ是他的为了防止重复发送而设定的一个标记，一般我们取当 前时间数值的一段放入即可。（C#：DateTime.Now.Ticks.ToString().Substring(7,7) DELPHI：CopyStr(inttostr(GetTickCount()),1,5)），UIN是说明你当前要登录的用户QQ号，PS，是md5 加密过后的密码的值。

返回协议：

VER=1.1&CMD=Login&SEQ=11281&UIN=&RES=0&RS=0&HI=60&LI=300（成功）

RES为0表示成功返回，RS为0表示登录成功。

VER=1.1&CMD=Login&SEQ=11422&UIN=315103947&RES=0&RS=1&RA=登录失败

RS为1表示登录失败，那么就会出现提示信息RA说明原因。

4、获得QQ名单。

如果您加了您的好友，那么您的好友就会放入你的QQ的好友名单里面，那么我们要得到QQ名单就必需给QQ服务器发送得到好友名单的协议（疯狂代码就不从复已知的参数了）：

VER=1.1&CMD=List&SEQ=&UIN=&TN=160&UN=0

服务器得到协议后如果成功则返回：

VER=1.1&CMD=LIST&SEQ=43661&UIN=29501213&RES=0&FN=1&SN=24&UN=561256,1943497,....

UN后面则是您好友的QQ号码，每个号码都由,进行分开。那么我们只需要得到UN后面的代码，把它列表化就OK了。C#可以用string.Split(',')把值放入列表进行处理，而DELPHI可以使用Split()把数值放入TStrings里进行处理。

5、获得QQ好友在线名单

获得QQ好友在线名单，跟获得好友名单差不多，唯一不同的是用的命令不同用的是Query_Stat，协议如下：

VER=1.1&CMD=Query_Stat&SEQ=&UIN=&TN=50&UN=0

服务器得到协议后如果成功则返回：

VER=1.1&CMD=QUERY_STAT&SEQ=-1&UIN=29501213&RES=0&FC=141,270,270,&FN=1&SN=3&ST=10,10,10,&UN=

FC为QQ头像的的ID，如的头像ID为270，那么其头使用的图片为91.bmp,其算法为ID/3+1。ST为QQ用户的状态，10为上线，20为离线，30为忙碌。UN为在线用户的QQ号，NK为在线用户的QQ昵称。ST，UN，NK，每个逗号隔开的数据相互对应。

6、得到QQ用户的信息。

如果要看到QQ用户的真实名称，MAIL，年龄，个人说明等信息，那么我们必需要向服务器发送得到好友信息的信息：

VER=1.1&CMD=GetInfo&SEQ=&UIN=&LV=2&UN=

UN为要查看用户信息的QQ号。

服务器得到协议后如果成功则返回：

VER=1.1& amp;CMD=GETINFO&SEQ=12707&UIN=415103947&RES=0&AD=云南昆明& amp;AG=0&EM=Microprogramer@hotmail.com&FC=270&HP=msger.org(建 设中...)&JB=程序员&LV=2&PC=650000&PH=0871-6466529&PR=网络为 媒%252c关系为本%252c信息为财%252c客户为主.%0d%0a&PV=云南省&RN=刘X&SC=社会大学& amp;SX=0&UN=24259132&NK=微程

AD用户的联系地址，AG为用户年龄，EM为用户MAIL，FC 为用户头像，HP为用户网站，JB为用户职业，PC为用户邮编，PH为用户联系电话，PR为用户简介，PV为用户所以的省，RN为用户真实名称，SC为用 户毕业院校，SX为用户性别，UN为用户QQ号，NK为用户QQ昵称。

7、增加QQ好友。

想要新增好友，就要发送AddToList命令给服务器，具体命令如下：

VER=1.1&CMD=AddToList&SEQ=&UIN=&UN=

UN为我们要增加用户的QQ号。

服务器得到协议后如果成功则返回：

VER=1.1&CMD=AddToList&SEQ=13666&UIN=415103947&RES=0&CD=0&UN=24259132

CD 为被加QQ的身份验证状态，CD为0表示“允许任何人把我列为好友”，CD为1表示“需要身份证认才能把我列为好友”，CD为3表示“不允许任何人把我列 为好友”。如果CD为0那么信息回馈后，用户就直接加为好友了，如果CD为1，那么还要发送一次回应加为好友的响应。

8、回应加为好友的响应。

回应加为好友响应是双方的：1、如果你发送了请求加对方为好友，如果对方需要验证，那么必需发送回应加为好友的响应。2、如果对方发送加为好友请求给你，那么你可以加应加为好友的响应，一是加为好友，一是通过验证，一是拒决加为好友。我们要向服务器发送命令：

VER=1.1&CMD=Ack_AddToList&SEQ=&UIN=&UN=&CD=&RS=

CD为响应状态，CD为0表示“通过验证”。CD为1表示“拒决加为对方为好友”。CD为2表示“为请求对方加为好友”。RS为你要请求的理由.

服务器得到协议后如果成功则返回：

VER=1.1&CMD=Ack_AddToList&SEQ=1130&UIN=415103947&RES=0&

9、删除好友。

删除好友其实很容易，向服务器发送DelFromList命令则可以删除用户：

VER=1.1&CMD=DelFromList&SEQ=&UIN=&UN=

UN为要删除用户的QQ号。

服务器得到协议后如果成功则返回：

VER=1.1&CMD=DelFromList&SEQ=24514&UIN=415103947&RES=0&

10、改变用户当前状态。

可以把QQ设置为在线，隐身等状态，我们可以发送Change_Stat给服务器以改变当前状态，具体命令如下：

VER=1.1&CMD=Change_Stat&SEQ=&UIN=&ST=

ST为要改变的状态，10为上线，20为离线，30为忙碌。

服务器得到协议后如果成功则返回：

VER=1.1&CMD=Change_Stat&SEQ=17512&UIN=415103947&RES=0&

11、退出登录

要退出登录，要向服务器发送命令Logout，具体命令如下：

VER=1.1&CMD=Logout&SEQ=&UIN=

服务器得到协议后如果成功则返回：

VER=1.1&CMD=LOGOUT&SEQ=15803&UIN=415103947&RES=0

12、获得好友QQ的消息

如果要接收好友的消息，要向服务器发送命令GetMsgEx，具体命令如下：

VER=1.1&CMD=GetMsgEx&SEQ=&UIN=

服务器得到协议后如果成功则返回：

VER=1.1&CMD=GETMSGEX&SEQ=56661&UIN=29501213&RES=0&MN=3&MT=99,9,9,&UN=24259132,24259132,24259132,&MG=30 ,asdfasdfasdfasdf ,asdfasdfasdf ,&

MT表示消息类型，99表示系统消息，9表示用户消息。 UN表示消息发送来源用户，MG表示发送的消息，MG消息可以表示某些特定的系统含意，譬如：当MT为99，MG为30，UN为24259132则表示用 户4259132现在处于忙碌状态，可根据此消息进行好友列表的刷新，提高效率。

13、向好友QQ发送消息

要发送消息给好友，要向服务器发送命令CLTMSG命令，具体命令如下：

VER=1.1&CMD=CLTMSG&SEQ=&UIN=&UN=&MG=

UN为消息发送给的用户QQ号码，MG为发送给该用户的消息。

服务器得到协议后如果成功则返回：

VER=1.1&CMD=CLTMSG&SEQ=15803&UIN=415103947&RES=0

好了，以上就是QQ基于HTTP的一个不完全的协议分析，利用以上协议您就可以实现很多东西，如：QQ机器人，QQ广告系统，即时通讯的整合工具等等

QQ协议网络协议--请求部份

//登录

VER=1.0&CMD=Login&SEQ=&UIN=&PS=&M5=1&LC=9326B87B234E7235

//获取消息

VER=1.0&CMD=GetMsgEx&SEQ=&UIN=

//发送消息

VER=1.0&CMD=CLTMSG&SEQ=&UIN=&UN=&MG=

//朋友列表

VER=1.0&CMD=List&SEQ=&UIN=&TN=160&UN=0

//获取好友状态

VER=1.0&CMD=Query_Stat&SEQ=&UIN=&TN=50&UN=0

//获取好友信息

VER=1.0&CMD=GetInfo&SEQ=&UIN=&LV=2&UN=

//增加好友

VER=1.0&CMD=AddToList&SEQ=&UIN=&UN=

//回应对方请求加你为好友的响应

VER=1.0&CMD=Ack_AddToList&SEQ=&UIN=&UN=&CD=&RS=

//删除好友

VER=1.0&CMD=DelFromList&SEQ=&UIN=&UN=

//搜索好友

VER=1.0&CMD=Finger&SEQ=&UIN=&AG=&SX=&PV=

//改变自己状态，ST的代码应该和获取好友状态代码一致

VER=1.0&CMD=Change_Stat&SEQ=&UIN=&ST=

//退出登录

VER=1.0&CMD=Logout&SEQ=&UIN=