最近写的一个MSN监测模块

最近在做一个网络行为管理的项目， MSN协议是其中的一个模块， 目前只是实现了对即时聊天内容以及帐号的监控， 对离线信息以及音频、 视频、 文件传输等还没有实现。 贴出来的代码是MSN分析的核心模块， 配合wpcap的抓包功能可以比较完美的检测局域网环境下所有MSN即时聊天信息， 支持中文。

MsnAnalysis.h

/**********************************************
*            MSN协议分析类
**********************************************/

#ifndef _MSN_ANALYSIS_H
#define _MSN_ANALYSIS_H

#include <map>
#include "activeuser.h"
#include "netheaders.h"

#define MSN_NOCONTENT        2    // have no MSN contents

using namespace std;

typedef struct tagMsnAccountPair        //MSN account pair structure
{
    char local_account[200];
    char remote_account[200];
} SMsnAccountPair, *PSMsnAccountPair;

typedef struct tagMsnInfo            //MSN session Info
{
    SMsnAccountPair msn_account_pair;
    char direct;
    char content[1000];
} SMsnInfo, *PSMsnInfo;


class CMsnAnalysis
{
public:
    CMsnAnalysis();
    ~CMsnAnalysis();
    
    // USER_ERROR:    packet is not MSN protocol
    // USER_SUCCEED: packet is MSN protocol and analyze MSN contents successfully
    // MSN_NOCONTENT:  packet is MSN protocol but have no MSN contents
    int Run(PIPHeader ip_header, PTCPHeader tcp_header, const char* data, const int direct, \
        Single_User_App_Details* suad, PSMsnInfo msn_info);

protected:
    int ParseIp(char* start, int length);
    map<unsigned __int64, SMsnAccountPair> m_mapMsnAccountPair;  //STL map structure, store MSN session account info

};



#endif

 

MsnAnalysis.cpp

#include "MsnAnalysis.h"

CMsnAnalysis::CMsnAnalysis()
{

}

CMsnAnalysis::~CMsnAnalysis()
{

}

// USER_SUCCDDD: analysis MSN talk contents successfully            MSN_NOCONTENTS: is MSN protocol packet, but without talk contents
// USER_ERROR: Not MSN protocol packet
// especially deal with VER, RNG, XFR, JOI, MSG and OUT command, XFR and RNG execute Insert operations, JOI and MSG execute Find operations, 
// OUT execute Erase operations
int CMsnAnalysis::Run(PIPHeader ip_header, PTCPHeader tcp_header, const char* data, const int direct, \
                  Single_User_App_Details* suad, PSMsnInfo msn_info)
{
    if (suad->remote_port != 1863)                // MSN protocol use 1863 port, but 1863 port maybe not MSN protocol
    {
        return USER_ERROR;
    }

    if ((data[0] == 'V' && data[1] == 'E' && data[2] == 'R') ||        // first command for DS and NS
        (data[0] == 'U' && data[1] == 'S' && data[2] == 'R') )        // first command for SB
    {
        suad->app_id = APPID_MSN;
        suad->app_confirm = 2;
        return MSN_NOCONTENT;
    }

    if (data[0] =='X' && data[1] == 'F' && data[2] == 'R' && WAN2LAN == direct)        // for MSN talk sponsor
    {        
        char* p = (char*)strstr(data, "SB");                        // get SB server IP
        char* q = NULL;
        if (p != NULL)
        {
            ULONG sb_ip = 0;
            p = p + 3;

            for (int i = 0; i < 3; i++)        //parse SB ip
            {
                q = strchr(p, '.');
                if (NULL == q)
                {
                    OutputDebugStringA("XFR: strchr('.')  ERROR!\n");
                    exit(1);
                }
                int n = q - p;
                sb_ip = sb_ip + (ParseIp(p, n)<<(8*(3-i)));
                p = q + 1;
            }

            q = strchr(p, ':');
            if (NULL == q)
            {
                OutputDebugStringA("XFR: strchr(':')  ERROR!\n");
                exit(1);
            }
            int n = q - p;
            sb_ip = sb_ip + ParseIp(p, n);    

            unsigned __int64 key = (((unsigned __int64)(ip_header->destination))<<32) + sb_ip;    // key = local_ip<<32 + sb_ip; so that it's unique
            SMsnAccountPair account_pair;
            account_pair.local_account[0] = '\0';
            account_pair.remote_account[0] = '\0';
            m_mapMsnAccountPair.insert(map<unsigned __int64, SMsnAccountPair>::value_type(key, account_pair));
        }
        return MSN_NOCONTENT;
    }

    if(data[0] =='R' && data[1] == 'N' && data[2] == 'G')        // for MSN talk participator
    {
        ULONG sb_ip = 0;
        char* p = (char*)data + 4;                        
        char* q = strchr(p, ' ');
        p = q + 1;
                
        for (int i = 0; i < 3; i++)        //get SB server IP
        {
            q = strchr(p, '.');
            if (NULL == q)
            {
                OutputDebugStringA("RNG: strchr('.')  ERROR!\n");
                exit(1);
            }
            int n = q - p;
            sb_ip = sb_ip + (ParseIp(p, n)<<(8*(3-i)));
            p = q + 1;
        }

        q = strchr(p, ':');
        if (NULL == q)
        {
            OutputDebugStringA("RNG: strchr(':')  ERROR!\n");
            exit(1);
        }
        int n = q - p;
        sb_ip = sb_ip + ParseIp(p, n);    

        unsigned __int64 key = (((unsigned __int64)(ip_header->destination))<<32) + sb_ip;    // key = local_ip<<32 + sb_ip; so that it's unique
        
        p = q + 6;
        for (int i = 0; i < 2; i++)        // point to the start position of remote account 
        {
            q = strchr(p, ' ');
            if (NULL == q)
            {
                OutputDebugStringA("RNG: strchr(' ')  start of remote account ERROR!\n");
                exit(1);
            }
            p = q + 1;
        }

        q = strchr(p, ' ');        // the end of remote account
        if (NULL == q)
        {
            OutputDebugStringA("RNG: strchr(' ')  end of remote account ERROR!\n");
            exit(1);
        }

        SMsnAccountPair account_pair;
        account_pair.local_account[0] = '\0';
        memcpy(account_pair.remote_account, p, q-p);
        account_pair.remote_account[q-p] = '\0';

        m_mapMsnAccountPair.insert(map<unsigned __int64, SMsnAccountPair>::value_type(key, account_pair));

        return MSN_NOCONTENT;
    }

    if (data[0] =='J' && data[1] == 'O' && data[2] == 'I')    // get MSN accounts
    {
        char account[200] = "";

        char* p = (char*)data + 4;
        char* q = (char*)strchr(p, ' ');
        if (NULL == q)
        {
            OutputDebugStringA("JOI: strchr(' ')  ERROR!\n");
            exit(1);
        }
        memcpy(account, p, q-p);        // get account
        account[q-p] = '\0';

        char* flag = strchr(account, ';'); // deal with condition aaaaa@msn.com;{e34adaaaadfdafff}
        if (flag != NULL)
        {
            *flag = '\0';
        }

        unsigned __int64 key = (((unsigned __int64)(ip_header->destination))<<32) + ip_header->source;
        map<unsigned __int64, SMsnAccountPair>::iterator iter = m_mapMsnAccountPair.find(key);
        if (iter == m_mapMsnAccountPair.end())
        {
            OutputDebugStringA("JOI: map.find() error!\n");
            //exit(1);
        }
        else    //modify account
        {
            if(!strcmp(iter->second.local_account, ""))
            {
                strcpy(iter->second.local_account, account);                
            }
            else if (!strcmp(iter->second.remote_account, ""))
            {
                strcpy(iter->second.remote_account, account);
            }
        }
        return MSN_NOCONTENT;            
    }

    if (data[0] =='M' && data[1] == 'S' && data[2] == 'G')        // MSN contents
    {        
        if (strstr(data, "Content-Type: text/plain") != NULL)        // have contents
        {
            char* p = (char*)data + 4;
            char* q = NULL;

            for (int i = 0; i < 2; i++)
            {
                q = strchr(p, ' ');
                if (NULL == q)
                {
                    OutputDebugStringA("MSG: strchr(' ')  ERROR!\n");
                    exit(1);
                }
                p = q + 1;
            }

            // calculate payload length
            q = strstr(p, "\r\n");
            if (NULL == q)
            {
                OutputDebugStringA("MSG: strstr('\r\n')  ERROR!\n");
                exit(1);
            }
            char arrLength[4] = "";
            memcpy(arrLength, p, q-p);
            arrLength[q-p] = '\0';
            int payload_length = atoi(arrLength);
            
            //calculate (payload_length-content_length)
            int head_length = 0;
            p = q + 2;
            char* end = (char*)strstr(data, "\r\n\r\n");
            if (NULL == end)
            {
                OutputDebugStringA("MSG: strstr('\r\n\r\n')  ERROR!\n");
                exit(1);
            }            
            while ((q = strstr(p, "\r\n")) != NULL && p != (end+4))
            {
                head_length = head_length + (q - p) + 2;
                p = q + 2;
            }
            
            char contents[1000] = "";
            memcpy(contents, p, payload_length-head_length);
            contents[payload_length-head_length] = '\0';
            WCHAR w_contents[500] = L"";
            MultiByteToWideChar(CP_UTF8, NULL, contents, -1, w_contents, 1000);        // UTF-8 to Unicode
            WideCharToMultiByte(CP_ACP, NULL, w_contents, -1, msn_info->content, 1000, NULL, false);        //Unicode to Ansi

            msn_info->direct = direct;        // set    direction

            ULONG local_ip = 0;
            if (LAN2WAN == direct)
            {
                local_ip = ip_header->source;
            }
            else
            {
                local_ip = ip_header->destination;
            }
            
            // set account pair
            unsigned __int64 key = 0;
            key = (((unsigned __int64)(local_ip))<<32) + suad->remote_ip;
            map<unsigned __int64, SMsnAccountPair>::iterator iter = m_mapMsnAccountPair.find(key);
            if (iter == m_mapMsnAccountPair.end())
            {
                OutputDebugStringA("MSG: map.find() error!\n");
                //exit(1);        // Mark this, if program runs here, we cannot get correct account info. 
                                // This could be happened if not enough user login info has been collected
            }
            else    //modify account
            {
                strcpy(msn_info->msn_account_pair.local_account, iter->second.local_account);
                strcpy(msn_info->msn_account_pair.remote_account, iter->second.remote_account);
            }
            
            return USER_SUCCEED;
        }
        else
        {
            return MSN_NOCONTENT;
        }
    }
    
    if (data[0] =='O' && data[1] == 'U' && data[2] == 'T')        // OUT command
    {
        ULONG local_ip = 0;
        if (LAN2WAN == direct)
        {
            local_ip = ip_header->source;
        }
        else
        {
            local_ip = ip_header->destination;
        }

        unsigned __int64 key = 0;
        key = (((unsigned __int64)(local_ip))<<32) + suad->remote_ip;

        map<unsigned __int64, SMsnAccountPair>::iterator iter = m_mapMsnAccountPair.find(key);
        if (iter != m_mapMsnAccountPair.end())        //found
        {
            m_mapMsnAccountPair.erase(iter);
        }

        return MSN_NOCONTENT;
    }

    if (APPID_MSN == suad->app_id)        // other MSN command
    {
        return MSN_NOCONTENT;
    }
    else        // remote port is 1863, but is not MSN protocol 
    {
        return USER_ERROR;
    }
}

int CMsnAnalysis::ParseIp(char* start, int length)
{
    char ip[4] = "";
    memcpy(ip, start, length);
    ip[length] = '\0';
    return atoi(ip);
}

//CString UTF8toUnicode(char* s)
//{
//    int len = 0;
//    WCHAR* r = new WCHAR[strlen(s) * 2];
//    while(s[0])
//    {
//        int bytes = 1;
//        if(s[0] & 0x80)
//            while(s[0] & (0x80 >> bytes)) bytes++;
//        if(bytes == 1)
//            r[len] = s[0];
//        else
//        {
//            r[len] = 0;
//            for(char*p = s + (bytes - 1); p > s; p--)
//                r[len] |= ((*p) & 0x3F) << ((bytes - (p - s) - 1) * 6);
//            r[len] |= (s[0] & ((1 << (7 - bytes)) - 1)) << ((bytes - 1) * 6);
//        }
//        len++;
//        s += bytes;
//    }
//    r[len] = 0;
//    char*buffer = new char[len * 2 + 1];
//    ZeroMemory(buffer, len * 2 + 1);
//    ::WideCharToMultiByte(CP_ACP, NULL, r, len, buffer, 1+ 2 * len, NULL, NULL);
//    CString str = buffer;
//    Delete[] r;
//    delete[] buffer;
//    return str;
//}