注册 登录
编程论坛 → 汇编论坛

请教一下，如何做一个截获报文并修改报文的小软件？（编辑HTTP Request）

wsz9903011 发布于 2009-08-13 23:03， 9799 次点击
RT所示，虽然有HttpAnalyzerStdV3 这样的截获报文的 软件 但是并没有能编辑截获报文的功能 ，比如编个软件输入某个网址 截获要发出的报文 可以对这个报文进行编辑，（可以编辑也可以不编辑）按确定 报文被发送。然后接受回复的报文 再次被截获可以再次编辑
请问各位 这需要哪些API实现？？ 主要是截获报文这一步（但不像HttpAnalyzerStdV3，只截获了就不管 ），还需要对接受（发送的）报文进行编辑
主要是没思路，能指点一二吗？？  话说zklhp老大的 QQ状态查询器 有点架子 可以在源文件里事先对报文进行编辑了 再编译了 然后再发送 配合HttpAnalyzerStdV3  。但截获的就没办法编辑了。而且离标题的要求还是太远了
16 回复
#2
zklhp2009-08-14 19:50
截获的话抓包器就可以 这个自己写比较麻烦罢 得用类似WinCap之类的~~~

HttpAnalyzerStdV3 是啥啊~~~
#3
zklhp2009-08-14 19:52
可以在源文件里事先对报文进行编辑了 再编译了 然后再发送 配合HttpAnalyzerStdV3  。但截获的就没办法编辑了。而且离标题的要求还是太远了

谁说不能在运行的时候改？？？

直接改数据包就可以了   哪用再编译？？？
#4
zklhp2009-08-14 19:52
而且离标题的要求还是太远了  

什么意思啊~
#5
nzxhust2009-08-14 22:25
这个好像有个叫WPE的可以吧做挂的都用，就是抓包在发假报欺骗的
#6
东海一鱼2009-08-14 22:28
可以截获的方法如下：

1、HOOK API拦截socket的send、recv函数实现截获修改。很多网络游戏外挂就是这末做的。
2、HOOK KERNEL API的相应函数。同上，不过是在ring0上实现。
3、直接写一个NDIS Filter网络层过滤驱动。卡巴斯基、天网、ComView等等都有实现。
#7
wsz99030112009-08-15 01:16
以下是引用zklhp在2009-8-14 19:52的发言：而且离标题的要求还是太远了  什么意思啊~
比如你的那个程序是在“要查询QQ号”框里输入QQ号 通过szSendFmt 这个报文发送到服务器（然后接受返回的报文）配合HttpAnalyzerStdV3软件 可以查看截获的报文 然后我通过修改你的程序 把“要查询QQ号”框里输入 我需要的网址  然后把szSendFmt 报文模板 稍微改成适应那个网站的形式（其他地方再改一下编译） 这样的话相当于“修改要发送的报文”（可以改掉当中的一些对于那个网站需要的命令） 来达到接受 对自己有用的报文数据 （小小的声明下 我没想去搞坏事 ）当然还需要 HttpAnalyzerStdV3软件 来抓报文 那个程序没这功能。  但跟设想的编个软件 有抓报文的功能 且能编辑报文（比如在IE里输入URL 按回车的瞬间被设想的软件截获报文 并比如弹出个框里面是要发出的报文你可以编辑这个报文并按确定或可以不编辑直接按确定，此时报文才真的被送上路，接受返回的信息到IE显示的当中可以再次被设想的软件截获报文也可以编辑 完毕才到IE那里） 所以说里题目要求还是太远按6楼兄弟讲的话 那我目前是没这个能力 对HOOK 还是不懂 不过发这个帖子主要是 想得到个思路有个方向  以便有个目标 知道要补充那些知识  比如zklhp老大讲的WinCap之类 的这个就要好好 知道下
#8
zklhp2009-08-17 13:17
截获数据表比较麻烦啊~~~~~
#9
非虫2009-08-17 14:13
以下是引用东海一鱼在2009-8-14 22:28的发言：3、直接写一个NDIS Filter网络层过滤 ...
老大！！你写个看看！这是驱动级最难的了！
#10
zklhp2009-08-17 20:58
以下是引用非虫在2009-8-17 14:13的发言：老大！！你写个看看！这是驱动级最难的了！
支持！！！
#11
东海一鱼2009-08-18 07:09
回复 9楼 非虫

嗬嗬，我还真写过一个。写得不好，请多指教。

程序代码：
#include "precomp.h"
#pragma hdrstop
#pragma NDIS_INIT_FUNCTION(DriverEntry)

 
#define LINKNAME_STRING     L"\\DosDevices\\NDIS_INFACE"
#define NTDEVICE_STRING     L"\\Device\\MYNDIS_001"              //我的设备：〉

 
UINT            g_BanDing = 0;

 
NDIS_HANDLE                        ProtHandle = NULL;
NDIS_HANDLE                        DriverHandle = NULL;
NDIS_MEDIUM                        MediumArray[4] =                       //支持的物理网络类型
                                    {
                                        NdisMedium802_3,    // Ethernet
                                        NdisMedium802_5,    // Token-ring
                                        NdisMediumFddi,        // Fddi
                                        NdisMediumWan       // NDISWAN
                                    };

 
NDIS_SPIN_LOCK    GlobalLock;

 
PADAPT            pAdaptList = NULL;
LONG            MiniportCount = 0;

 
NDIS_HANDLE        NdisWrapperHandle;  

 
NDIS_HANDLE     NdisDeviceHandle = NULL;
PDEVICE_OBJECT  ControlDeviceObject = NULL;
enum _DEVICE_STATE
{
    PS_DEVICE_STATE_READY = 0,   
    PS_DEVICE_STATE_CREATING,   
    PS_DEVICE_STATE_DELETING   
}                ControlDeviceState = PS_DEVICE_STATE_READY;

 

 

 
NTSTATUS
DriverEntry(
    IN    PDRIVER_OBJECT        DriverObject,
    IN    PUNICODE_STRING        RegistryPath
    )
{
    NDIS_STATUS                        Status;
    NDIS_PROTOCOL_CHARACTERISTICS    PChars;
    NDIS_MINIPORT_CHARACTERISTICS    MChars;
    PNDIS_CONFIGURATION_PARAMETER    Param;
    NDIS_STRING                        Name;

 
    Status = NDIS_STATUS_SUCCESS;
    NdisAllocateSpinLock(&GlobalLock);

 
    NdisMInitializeWrapper(&NdisWrapperHandle, DriverObject, RegistryPath, NULL);

 
    do
    {         
        NdisZeroMemory(&MChars, sizeof(NDIS_MINIPORT_CHARACTERISTICS));

 
        MChars.MajorNdisVersion = PASSTHRU_MAJOR_NDIS_VERSION;
        MChars.MinorNdisVersion = PASSTHRU_MINOR_NDIS_VERSION;

 
        MChars.InitializeHandler = MPInitialize;
        MChars.QueryInformationHandler = MPQueryInformation;
        MChars.SetInformationHandler = MPSetInformation;
        MChars.ResetHandler = MPReset;
        MChars.TransferDataHandler = MPTransferData;
        MChars.HaltHandler = MPHalt;
#ifdef NDIS51_MINIPORT
        MChars.CancelSendPacketsHandler = MPCancelSendPackets;
        MChars.PnPEventNotifyHandler = MPDevicePnPEvent;
        MChars.AdapterShutdownHandler = MPAdapterShutdown;
#endif // NDIS51_MINIPORT

 
        MChars.CheckForHangHandler = NULL;
        MChars.ReturnPacketHandler = MPReturnPacket;

 
        //
        // 采用多包发送
        //
        MChars.SendHandler = NULL;    // MPSend;
        MChars.SendPacketsHandler = MPSendPackets;

 
        Status = NdisIMRegisterLayeredMiniport(NdisWrapperHandle,
                                                  &MChars,
                                                  sizeof(MChars),
                                                  &DriverHandle);
        if (Status != NDIS_STATUS_SUCCESS)
        {
            break;
        }

 
#ifndef WIN9X
        NdisMRegisterUnloadHandler(NdisWrapperHandle, PtUnload);
#endif

 
        //
        // 注册我的协议
        //
        NdisZeroMemory(&PChars, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
        PChars.MajorNdisVersion = PASSTHRU_PROT_MAJOR_NDIS_VERSION;
        PChars.MinorNdisVersion = PASSTHRU_PROT_MINOR_NDIS_VERSION;

 
        NdisInitUnicodeString(&Name, L"XNDF");    // 我的协议名称，哈哈
        PChars.Name = Name;
        PChars.OpenAdapterCompleteHandler = PtOpenAdapterComplete;
        PChars.CloseAdapterCompleteHandler = PtCloseAdapterComplete;
        PChars.SendCompleteHandler = PtSendComplete;
        PChars.TransferDataCompleteHandler = PtTransferDataComplete;
     
        PChars.ResetCompleteHandler = PtResetComplete;
        PChars.RequestCompleteHandler = PtRequestComplete;
        PChars.ReceiveHandler = PtReceive;
        PChars.ReceiveCompleteHandler = PtReceiveComplete;
        PChars.StatusHandler = PtStatus;
        PChars.StatusCompleteHandler = PtStatusComplete;
        PChars.BindAdapterHandler = PtBindAdapter;
        PChars.UnbindAdapterHandler = PtUnbindAdapter;
        PChars.UnloadHandler = PtUnloadProtocol;

 
        PChars.ReceivePacketHandler = PtReceivePacket;
        PChars.PnPEventHandler= PtPNPHandler;

 
        NdisRegisterProtocol(&Status,
                             &ProtHandle,
                             &PChars,
                             sizeof(NDIS_PROTOCOL_CHARACTERISTICS));

 
        if (Status != NDIS_STATUS_SUCCESS)
        {
            NdisIMDeregisterLayeredMiniport(DriverHandle);
            break;
        }

 
        NdisIMAssociateMiniport(DriverHandle, ProtHandle);
    }
    while (FALSE);

 
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NdisTerminateWrapper(NdisWrapperHandle, NULL);
    }

 
    return(Status);
}

 

 
NDIS_STATUS
PtRegisterDevice(
    VOID
    )
{
    NDIS_STATUS            Status = NDIS_STATUS_SUCCESS;
    UNICODE_STRING        DeviceName;
    UNICODE_STRING        DeviceLinkUnicodeString;
    PDRIVER_DISPATCH    DispatchTable[IRP_MJ_MAXIMUM_FUNCTION];
    UINT                i;

 
    DBGPRINT(("==>PtRegisterDevice\n"));

 
    NdisAcquireSpinLock(&GlobalLock);

 
    ++MiniportCount;
     
    if (1 == MiniportCount)
    {
        ASSERT(ControlDeviceState != PS_DEVICE_STATE_CREATING);

 
        while (ControlDeviceState != PS_DEVICE_STATE_READY)
        {
            NdisReleaseSpinLock(&GlobalLock);
            NdisMSleep(1);
            NdisAcquireSpinLock(&GlobalLock);
        }

 
        ControlDeviceState = PS_DEVICE_STATE_CREATING;

 
        NdisReleaseSpinLock(&GlobalLock);

 
        for (i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
        {
            DispatchTable[i] = PtDispatch;
        }

 
        NdisInitUnicodeString(&DeviceName, NTDEVICE_STRING);
        NdisInitUnicodeString(&DeviceLinkUnicodeString, LINKNAME_STRING);

 
        //
        // 创建设备对象并绑定驱动回调函数组
        //
         
        Status = NdisMRegisterDevice(
                    NdisWrapperHandle,
                    &DeviceName,
                    &DeviceLinkUnicodeString,
                    &DispatchTable[0],
                    &ControlDeviceObject,
                    &NdisDeviceHandle
                    );

 
        NdisAcquireSpinLock(&GlobalLock);

 
        ControlDeviceState = PS_DEVICE_STATE_READY;
    }

 
    NdisReleaseSpinLock(&GlobalLock);

 
    DBGPRINT(("<==PtRegisterDevice: %x\n", Status));

 
    return (Status);
}


[ 本帖最后由 东海一鱼 于 2009-8-18 07:39 编辑 ]
#12
东海一鱼2009-08-18 07:21
这个论坛够‘霉’的，字数检测说少于50000子的代码可发。结果才40000多字就出错。
#13
东海一鱼2009-08-18 07:31
程序代码：
NDIS_STATUS
PtReceive(
    IN  NDIS_HANDLE            ProtocolBindingContext,
    IN  NDIS_HANDLE            MacReceiveContext,
    IN  PVOID                HeaderBuffer,
    IN  UINT                HeaderBufferSize,
    IN  PVOID                LookAheadBuffer,
    IN  UINT                LookAheadBufferSize,
    IN  UINT                PacketSize
    )
{
    PADAPT            pAdapt =(PADAPT)ProtocolBindingContext;
    PNDIS_PACKET    Packet,MyPacket,LookAheadPacket,LaterPacket;
    NDIS_STATUS        Status = NDIS_STATUS_SUCCESS;
    PUCHAR            pPacketContent,pLookAheadContent,pLaterContent;
    PNDIS_BUFFER    pPacketBuffer,pLookAheadBuffer,pLaterBuffer;
    NDIS_PHYSICAL_ADDRESS HighestAcceptableMax;
    UINT            OffsetSize,PacketLen,BytesTransferred;
    PRECV_RSVD        Rsvd=NULL;
     

 
    HighestAcceptableMax.LowPart = -1;
    HighestAcceptableMax.HighPart = -1;
     

 
    if (!pAdapt->MiniportHandle)
    {
        Status = NDIS_STATUS_FAILURE;
    }
    else do
    {
        Packet = NdisGetReceivedPacket(pAdapt->BindingHandle, MacReceiveContext);
        if (Packet != NULL)
        {
            NdisDprAllocatePacket(&Status,
                                         &MyPacket,
                                         pAdapt->RecvPacketPoolHandle);

 
            if (Status == NDIS_STATUS_SUCCESS)
            {
                MyPacket->Private.Head = Packet->Private.Head;
                MyPacket->Private.Tail = Packet->Private.Tail;

 
                NDIS_SET_ORIGINAL_PACKET(MyPacket, NDIS_GET_ORIGINAL_PACKET(Packet));
                NDIS_SET_PACKET_HEADER_SIZE(MyPacket, HeaderBufferSize);

 
                //
                // 拷贝包标记
                //
                NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet);
                NDIS_SET_PACKET_STATUS(MyPacket, NDIS_STATUS_RESOURCES);

 
               NdisMIndicateReceivePacket(pAdapt->MiniportHandle, &MyPacket, 1);

 
               NdisDprFreePacket(MyPacket);

 
                break;
            }
        }
        ///////////////////////收包截获A///////////////////////////////////////////////////
        else if (LookAheadBufferSize>=PacketSize)
        {
            DBGPRINT (("1 PtReceive PacketSize=%d,LookAheadBufferSize=%d\n",PacketSize,LookAheadBufferSize));  
            
            Status=NdisAllocateMemory(&pPacketContent,BUFFER_SIZE,0,HighestAcceptableMax);
            if(Status!=NDIS_STATUS_SUCCESS)
            {
                DBGPRINT(("PTReceive:NdisAllocateMemory pPacketContent Failed\n"));
                break;  
            }
            if(pPacketContent==NULL)
            {
                DBGPRINT(("PTReceive:pPacketContent==NULL\n"));
                return(NDIS_STATUS_NOT_ACCEPTED);
            }  
            NdisZeroMemory(pPacketContent,BUFFER_SIZE);
            
            
            NdisMoveMemory(pPacketContent,HeaderBuffer,HeaderBufferSize);
            NdisMoveMemory(pPacketContent+HeaderBufferSize,LookAheadBuffer,LookAheadBufferSize);
            PacketLen=PacketSize+HeaderBufferSize;//接收包长度
            DBGPRINT(("+++++++++++MypacketContent  In   PtReceive 1+++++++++++++++++++"));

            MyFixRecv(pPacketContent,PacketLen);        ///////////我对包的处理（乾坤大挪移，哈），
            
            NdisDprAllocatePacket(&Status,&MyPacket,pAdapt->RecvPacketPoolHandle);
            if(Status!=NDIS_STATUS_SUCCESS)
            {
                NdisFreeMemory(pPacketContent,BUFFER_SIZE,0);
                break;
            }
            
            //分配buffer
            NdisAllocateBuffer(&Status,&pPacketBuffer,pAdapt->RcvBufferPoolHandle,pPacketContent,PacketLen);
            if (Status!=NDIS_STATUS_SUCCESS)
            {
                NdisFreeMemory(pPacketContent,BUFFER_SIZE,0);
                NdisDprFreePacket(MyPacket);
                break;  
            }
            
            //对分配的包作处理
            NdisChainBufferAtFront(MyPacket,pPacketBuffer);  
            MyPacket->Private.Head->Next=NULL;
            MyPacket->Private.Tail=NULL;

 
            Rsvd=(PRECV_RSVD)(MyPacket->MiniportReserved);
            Rsvd->OriginalPkt=NULL;
            NDIS_SET_PACKET_HEADER_SIZE(MyPacket,HeaderBufferSize);
            
            //提交包，如状态为PENDING，则调用MPReturnPacket
            NdisMIndicateReceivePacket(pAdapt->MiniportHandle,&MyPacket,1);
            
            if(NDIS_GET_PACKET_STATUS(MyPacket)!=NDIS_STATUS_PENDING)
            {
                DBGPRINT(("In PtReceive NDIS_GET_PACKET_STATUS(MyPacket)!=NDIS_STATUS_PENDING Free Memory\n"));
                NdisFreeBuffer(pPacketBuffer);
                NdisFreeMemory(pPacketContent,BUFFER_SIZE,0);
                NdisDprFreePacket(MyPacket);
            }
            break;

 
        }
        else
        {
            DBGPRINT (("2 PtReceive PacketSize=%d,LookAheadBufferSize=%d\n",PacketSize,LookAheadBufferSize));  
            ////////////////////////////组包接收LookAhead数据A//////////////////////////////////
            
            OffsetSize=HeaderBufferSize+LookAheadBufferSize;            
            
            Status=NdisAllocateMemory(&pLookAheadContent,BUFFER_SIZE,0,HighestAcceptableMax);  
            if(Status!=NDIS_STATUS_SUCCESS)
            {
                DBGPRINT(("PtReceive:NdisAllocateMemory pLookAheadContent Failed.\n"));
                break;
            }
            if(pLookAheadContent==NULL)
            {
                DBGPRINT(("PTReceive:pLookAheadContent==NULL\n"));
                return(NDIS_STATUS_NOT_ACCEPTED);
            }  
            NdisZeroMemory(pLookAheadContent,BUFFER_SIZE);
            
            NdisMoveMemory(pLookAheadContent,HeaderBuffer,HeaderBufferSize);
            NdisMoveMemory(pLookAheadContent+HeaderBufferSize,LookAheadBuffer,LookAheadBufferSize);            
            
            NdisAllocateBuffer(&Status,&pLookAheadBuffer,pAdapt->RcvBufferPoolHandle,pLookAheadContent,OffsetSize);
            if (Status!=NDIS_STATUS_SUCCESS)  
            {
                DBGPRINT(("PtReceive:NdisAllocateBuffer pPacketBuffer Failed.\n"));
                NdisFreeMemory(pLookAheadContent,BUFFER_SIZE,0);
                break;
            }            
            
            NdisDprAllocatePacket(&Status,&LookAheadPacket,pAdapt->RecvPacketPoolHandle);
            if (Status!=NDIS_STATUS_SUCCESS)
            {
                DBGPRINT(("PtReceive:NdisDprAllocatePacket LookAheadPacket Failed.\n"));
                NdisFreeMemory(pLookAheadContent,BUFFER_SIZE,0);
                NdisFreeBuffer(pLookAheadBuffer);
                break;
            }

 
            NdisChainBufferAtFront(LookAheadPacket,pLookAheadBuffer);
            LookAheadPacket->Private.Head->Next=NULL;
            LookAheadPacket->Private.Tail=NULL;
            

 
            ////////////////////////////组包接收后续数据A//////////////////////////////////
            
            //分配Memory，用于接收后续数据
            Status=NdisAllocateMemory(&pLaterContent,BUFFER_SIZE,0,HighestAcceptableMax);  
            if(Status!=NDIS_STATUS_SUCCESS)
            {
                DBGPRINT(("PtReceive:NdisAllocateMemory pLaterContent Failed.\n"));
                NdisFreeMemory(pLookAheadContent,BUFFER_SIZE,0);
                NdisFreeBuffer(pLookAheadBuffer);
                NdisDprFreePacket(LookAheadPacket);
                break;
            }
            if(pLaterContent==NULL)
            {
                DBGPRINT(("PTReceive:pLaterContent==NULL\n"));
                NdisFreeMemory(pLookAheadContent,BUFFER_SIZE,0);
                NdisFreeBuffer(pLookAheadBuffer);
                NdisDprFreePacket(LookAheadPacket);
                return(NDIS_STATUS_NOT_ACCEPTED);
            }  
            NdisZeroMemory(pLaterContent,BUFFER_SIZE);

 
            //分配pLaterBuffer
            NdisAllocateBuffer(&Status,&pLaterBuffer,pAdapt->RcvBufferPoolHandle,pLaterContent,PacketSize-LookAheadBufferSize);
            if (Status!=NDIS_STATUS_SUCCESS)
            {
                NdisFreeMemory(pLookAheadContent,BUFFER_SIZE,0);
                NdisFreeBuffer(pLookAheadBuffer);
                NdisDprFreePacket(LookAheadPacket);
                NdisFreeMemory(pLaterContent,BUFFER_SIZE,0);
                break;
            }
            
            //分配LaterPacket
            NdisDprAllocatePacket(&Status,&LaterPacket,pAdapt->RecvPacketPoolHandle);
            if (Status!=NDIS_STATUS_SUCCESS)
            {
                 
                NdisFreeMemory(pLookAheadContent,BUFFER_SIZE,0);
                NdisFreeBuffer(pLookAheadBuffer);
                NdisDprFreePacket(LookAheadPacket);
                NdisFreeMemory(pLaterContent,BUFFER_SIZE,0);
                NdisFreeBuffer(pLaterBuffer);
                break;
            }

 
            NdisChainBufferAtFront(LaterPacket,pLaterBuffer);
            LaterPacket->Private.Head->Next=NULL;
            LaterPacket->Private.Tail=NULL;

 
            NDIS_SET_PACKET_HEADER_SIZE(LaterPacket,HeaderBufferSize);

 
            ////////////////////////////组包接收后续数据V//////////////////////////////////

 
            //将先接到的数据包连接到后收到的数据包上
            Rsvd=(PRECV_RSVD)(LaterPacket->MiniportReserved);
            Rsvd->OriginalPkt=(PNDIS_PACKET)LookAheadPacket;
            
            //接收后续数据            
            NdisTransferData(&Status,pAdapt->BindingHandle,MacReceiveContext,LookAheadBufferSize,PacketSize-LookAheadBufferSize,LaterPacket,&BytesTransferred);
            
            if(Status!=NDIS_STATUS_PENDING)
            {
                DBGPRINT(("NdisTransferData != NDIS_STATUS_PENDING"));
                PtTransferDataComplete((NDIS_HANDLE)pAdapt,LaterPacket,Status,BytesTransferred);
            }
            break;
        }
        ///////////////////////收包截获V///////////////////////////////////////////////////  
        pAdapt->IndicateRcvComplete = TRUE;
        switch (pAdapt->Medium)
        {
          case NdisMedium802_3:
          case NdisMediumWan:
             NdisMEthIndicateReceive(pAdapt->MiniportHandle,
                                             MacReceiveContext,
                                             HeaderBuffer,
                                             HeaderBufferSize,
                                             LookAheadBuffer,
                                             LookAheadBufferSize,
                                             PacketSize);
             break;

 
          case NdisMedium802_5:
             NdisMTrIndicateReceive(pAdapt->MiniportHandle,
                                            MacReceiveContext,
                                            HeaderBuffer,
                                            HeaderBufferSize,
                                            LookAheadBuffer,
                                            LookAheadBufferSize,
                                            PacketSize);
             break;

 
          case NdisMediumFddi:
             NdisMFddiIndicateReceive(pAdapt->MiniportHandle,
                                              MacReceiveContext,
                                              HeaderBuffer,
                                              HeaderBufferSize,
                                              LookAheadBuffer,
                                              LookAheadBufferSize,
                                              PacketSize);
             break;

 
          default:
             ASSERT(FALSE);
             break;
        }

 
    } while(FALSE);

 
    return Status;
}


[ 本帖最后由 东海一鱼 于 2009-8-18 08:11 编辑 ]
#14
东海一鱼2009-08-18 07:36
拆得麻烦死了。就贴这末多吧。
#15
爱号者2009-09-03 13:23
Documents and Settings\SQWB\桌面\bc53b-20090902-sp6\20090902-sp6
#16
yeyang2015-05-24 11:39
#17
yeyang2015-05-24 17:13
说我想要做一个局域网内部的ARP防火墙，可以给点意见吗？
1
©2025, BCCN.NET
电脑版