(libusb) usb口自动刷新，2024年最新2024年网络安全开发者跳槽指南

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注网络安全）

正文

public:
static int Reset_context();

private:
char str[1024]{};

public:
/// libusb_init()
Reset();
/// libusb_exit()
~Reset();

public:
::std::vector<::std::string> Show_device();

public:
libusb_device_descriptor Find_descriptByidVendor(uint32_t Vendor);

public:
/**
* vendor -> device* -> handle*
* handle* -> reset
* handle* -> close
*/
libusb_device* Find_deviceByidVendor(uint32_t Vendor);
libusb_device_handle* Get_handleByOpenDevice(libusb_device* device);
int Reset_usbByHandle(libusb_device_handle* device_handle);
void Close_deviceByHandle(libusb_device_handle* device_handle);
};

} // namespace USB
#endif // MYUSB_H_1682212693

**USB\_Reset.cpp**

#include “USB_Reset.h”

namespace USB {
/**
* @brief UsbBase::context
* static data
* context: 所有对象共享这一个全局的上下文对象
* obj_count: 引用计数
*/
libusb_context* Reset::context = nullptr;
uint32_t Reset::obj_count = 0;

/**
* @brief UsbBase::Reset_context
* @return
* static 重置上下文
*/
int Reset::Reset_context() {
/// 有实体对象才重置 context
if (0 != obj_count) {
if (nullptr != context) {
libusb_exit(context);
context = nullptr;
}
return libusb_init(&context);
}
return LIBUSB_SUCCESS;
}

/**
* @brief UsbBase::UsbBase
* constructor
* 上下文的init
* 维护引用计数
*/
Reset::Reset() {
/// 查看版本号
const struct libusb_version* version = libusb_get_version();
printf(“>>>Libusb-Version:%s\n”, version->describe);
printf(“>>>Libusb-Version:%d.%d.%d.%d\n”,
version->major,
version->minor,
version->micro,
version->nano
);

/// 第一个对象，或者之前没有注册成功
if (0 == obj_count || nullptr == context) {
    if (int res = libusb\_init(&context); res != 0) {
        sprintf(str, "fail to init: %d\n", res);
        /// TODO
        /// 根据实际情况，日志、断言、异常等
        /// TODO
    }
}

obj_count += 1;

}

/**
* @brief UsbBase::~UsbBase
* distructor
* 维护引用计数
* 上下文的退出
*/
Reset::~Reset() {
obj_count += -1;
if (0 == obj_count) {
if (nullptr != context) {
libusb_exit(context);
context = nullptr;
}
}
}

/**
* @brief UsbBase::show_device
* just show device-list message
*/
::std::vector<::std::string> Reset::Show_device() {
::std::vector<::std::string> messageList;
messageList.push_back(
"********************** show device-list message BEGIN "
“**********************”);

/// help data
libusb_device\*\* deviceList = nullptr;
libusb\_get\_device\_list(nullptr, &deviceList);
for (int i = 0; deviceList[i] != nullptr; i += 1) {
    auto                            device = deviceList[i];
    struct libusb\_device\_descriptor descript;
    int ret = libusb\_get\_device\_descriptor(device, &descript);
    if (LIBUSB_SUCCESS != ret) {
        continue;
    }

    sprintf(str,
            "\*"
            "idVendor:%6d "
            "idProduct:%6d "
            "bDeviceClass:%6d "
            "(bus:%3d, device:%3d)"
            "\*",
            descript.idVendor, descript.idProduct, descript.bDeviceClass,
            libusb\_get\_bus\_number(device),
            libusb\_get\_device\_address(device));
    messageList.push\_back(str);
}
messageList.push\_back(
    "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* show device-list message END "
    "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");
return messageList;

}

/**
* @brief MyUsb::Find_descriptByidVendor
* @param idVendor
* @return
* 获取设备描述对象
*/
libusb_device_descriptor Reset::Find_descriptByidVendor(uint32_t idVendor) {
/// ret
libusb_device_descriptor descriptor;

/// help data
libusb_device_handle\* deviceHandle = nullptr;
libusb_device\*\*       deviceList   = nullptr;

libusb\_get\_device\_list(nullptr, &deviceList);
for (int i = 0; deviceList[i] != nullptr; i += 1) {
    auto device = deviceList[i];
    int  ret    = libusb\_get\_device\_descriptor(device, &descriptor);
    if (LIBUSB_SUCCESS != ret) {
        continue;
    }

    if (descriptor.idVendor == idVendor) {
        const int isOpen = libusb\_open(device, &deviceHandle);
        if (LIBUSB_SUCCESS == isOpen) {
            libusb\_close(deviceHandle);
            break;
        }
    }
}

return descriptor;

}

/**
* @brief UsbBase::Find_deviceByidVendor
* @param Vendor
* @return
* 获取device
*/
libusb_device* Reset::Find_deviceByidVendor(uint32_t Vendor) {
/// ret
libusb_device* device = nullptr;

/// help data
libusb_device_handle\* deviceHandle = nullptr;
libusb_device\*\*       deviceList   = nullptr;

libusb\_get\_device\_list(nullptr, &deviceList);
for (int i = 0; deviceList[i] != nullptr; i += 1) {
    device = deviceList[i];
    libusb_device_descriptor descriptor;
    int ret = libusb\_get\_device\_descriptor(device, &descriptor);
    if (LIBUSB_SUCCESS != ret) {
        continue;
    }

    if (descriptor.idVendor == Vendor) {
        const int isOpen = libusb\_open(device, &deviceHandle);
        if (LIBUSB_SUCCESS == isOpen) {
            libusb\_close(deviceHandle);
            break;
        } else {
            device = nullptr;
        }
    } else {
        device = nullptr;
    }
}

return device;

}

/**
* @brief UsbBase::Get_handleByOpenDevice
* @param device
* @return
* 根据传入的设备指针
* 通过open操作
* 获取句柄指针
*/
libusb_device_handle* Reset::Get_handleByOpenDevice(libusb_device* device) {
if (nullptr == device) {
return nullptr;
}
libusb_device_handle* deviceHandle = nullptr;
const int isOpen = libusb_open(device, &deviceHandle);
if (LIBUSB_SUCCESS == isOpen) {
return deviceHandle;
} else {
return nullptr;
}
}

/**
* @brief UsbBase::Reset_usbByHandle
* @param device_handle
* @return
* 通过句柄重置设备
* 为0则表示成功
*/
int Reset::Reset_usbByHandle(libusb_device_handle* device_handle) {
if (nullptr == device_handle) {
return EMPTY_POINTER_INT;
}
const int isReset = libusb_reset_device(device_handle);
//! TODO if (isReset ?= 0) => log
return isReset;
}

/**
* @brief UsbBase::Close_deviceByHandle
* @param device_handle
* 手动通过句柄指针关闭设备
*/
void Reset::Close_deviceByHandle(libusb_device_handle* device_handle) {
if (nullptr == device_handle) {
return;
}
libusb_close(device_handle);
}
} // namespace USB

**USB\_Hotplug.h**

#ifndef HOTPLUG_H_27452998650
#define HOTPLUG_H_27452998650

extern “C” {
#include “libusb-1.0/libusb.h”
}

namespace USB {
class Hotplug final {
private:
static libusb_device_handle *m_deviceHandle;

private:
static int LIBUSB_CALL usb_arrived_callback(struct libusb_context *ctx,
struct libusb_device *dev,
libusb_hotplug_event event,
void *userdata);
static int LIBUSB_CALL usb_left_callback(struct libusb_context *ctx,
struct libusb_device *dev,
libusb_hotplug_event event,
void *userdata);

private:
char str[1024]{};

private:
libusb_hotplug_callback_handle usb_arrived_handle;
libusb_hotplug_callback_handle usb_left_handle;
libusb_context *context = nullptr;

private:
uint32_t m_regiest_vendor = LIBUSB_HOTPLUG_MATCH_ANY;
uint32_t m_regiest_product = LIBUSB_HOTPLUG_MATCH_ANY;
uint32_t m_regiest_deviceClass = LIBUSB_HOTPLUG_MATCH_ANY;

private:
Hotplug();

public:
Hotplug(uint32_t vendor, uint32_t product, uint32_t deviceClass);
~Hotplug();

public:
int Register_arrived();
int Register_left();
};
} // namespace USB

#endif // HOTPLUG_H_27452998650

**USB\_Hotplug.cpp**

#include “USB_Hotplug.h”

#include

namespace USB {
/**
* @brief Hotplug::m_deviceHandle
* 主要用于静态的回调函数
*/
libusb_device_handle *Hotplug::m_deviceHandle = nullptr;

/**
* @brief Hotplug::usb_arrived_callback
* @param ctx
* @param dev
* @param event
* @param userdata
* @return
* 热拔插 arrive 的回调
*/
int Hotplug::usb_arrived_callback(libusb_context *ctx, libusb_device *dev,
libusb_hotplug_event event, void *userdata) {
struct libusb_device_handle *handle;
struct libusb_device_descriptor desc;
unsigned char buf[512];
int rc;

libusb\_get\_device\_descriptor(dev, &desc);
printf("Add usb device: \n");
printf("\tCLASS(0x%x) SUBCLASS(0x%x) PROTOCOL(0x%x)\n", desc.bDeviceClass,
       desc.bDeviceSubClass, desc.bDeviceProtocol);
printf("\tVENDOR(0x%x) PRODUCT(0x%x)\n", desc.idVendor, desc.idProduct);
rc = libusb\_open(dev, &handle);
if (LIBUSB_SUCCESS != rc) {
    printf("Could not open USB device\n");
    return 0;
}

memset(buf, 0, sizeof(buf));
rc = libusb\_get\_string\_descriptor\_ascii(handle, desc.iManufacturer, buf,
                                        sizeof(buf));
if (rc < 0) {
    printf("Get Manufacturer failed\n");
} else {
    printf("\tManufacturer: %s\n", buf);
}

memset(buf, 0, sizeof(buf));
rc = libusb\_get\_string\_descriptor\_ascii(handle, desc.iProduct, buf,
                                        sizeof(buf));
if (rc < 0) {
    printf("Get Product failed\n");
} else {
    printf("\tProduct: %s\n", buf);
}

memset(buf, 0, sizeof(buf));
rc = libusb\_get\_string\_descriptor\_ascii(handle, desc.iSerialNumber, buf,
                                        sizeof(buf));
if (rc < 0) {
    printf("Get SerialNumber failed\n");
} else {
    printf("\tSerialNumber: %s\n", buf);
}
libusb\_close(handle);

return 0;

}

/**
* @brief Hotplug::usb_left_callback
* @param ctx
* @param dev
* @param event
* @param userdata
* @return
* 热拔插left的回调
*/
int Hotplug::usb_left_callback(libusb_context *ctx, libusb_device *dev,
libusb_hotplug_event event, void *userdata) {
struct libusb_device_descriptor desc;
libusb_get_device_descriptor(dev, &desc);
const int isReset = libusb_reset_device(m_deviceHandle);
return isReset;
}

/**
* @brief Hotplug::Hotplug
* 构造的时候init
*/
Hotplug::Hotplug() {
libusb_init(&context);
}

/**
* @brief Hotplug::Hotplug
* @param vendor
* @param product
* 委托构造
*/
Hotplug::Hotplug(uint32_t vendor, uint32_t product, uint32_t deviceClass) : Hotplug() {
/// data
{
m_regiest_vendor = vendor;
m_regiest_product = product;
m_regiest_deviceClass = deviceClass;
}

/// find
{
    libusb_device \*\*m_deviceList;
    libusb\_get\_device\_list(nullptr, &m_deviceList);
    for (int i = 0; m_deviceList[i] != nullptr; i += 1) {
        auto                            device = m_deviceList[i];
        struct libusb\_device\_descriptor descript;
        int ret = libusb\_get\_device\_descriptor(device, &descript);
        if (ret < 0) {
            sprintf(
                str,
                "Error libusb\_get\_device\_descriptor idx = %d res = %d\n", i,
                ret);
        }

        if (descript.idVendor == vendor && descript.idProduct == product) {
            const int isOpen =
                libusb\_open(m_deviceList[i], &m_deviceHandle);
            if (LIBUSB_SUCCESS == isOpen) {
                break;
            }
        }
    }
}  /// find

/// test
{
    Register\_arrived();
    Register\_left();
}

}

/**
* @brief Hotplug::~Hotplug
* 析构的时候注销和释放句柄
*/
Hotplug::~Hotplug() {
libusb_hotplug_deregister_callback(context, usb_arrived_handle);
libusb_hotplug_deregister_callback(context, usb_left_handle);
libusb_exit(context);
}

/**
* @brief Hotplug::Register_arrived
* @return
* 注册热拔插arrive
*/
int Hotplug::Register_arrived() {
int res = libusb_hotplug_register_callback(
context, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, LIBUSB_HOTPLUG_NO_FLAGS,
m_regiest_vendor, m_regiest_product, m_regiest_deviceClass,
Hotplug::usb_arrived_callback, NULL, &usb_arrived_handle);
return res;
}

/**
* @brief Hotplug::Register_left
* @return
* 注册热拔插left
*/
int Hotplug::Register_left() {
int res = libusb_hotplug_register_callback(
context, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, LIBUSB_HOTPLUG_NO_FLAGS,
m_regiest_vendor, m_regiest_product, m_regiest_deviceClass,
Hotplug::usb_left_callback, NULL, &usb_left_handle);
return res;
}
} // namespace USB

#### `code`包


**WIDGET\_Main.h**

#ifndef FORM_H_27453073957
#define FORM_H_27453073957

#include
#include
#include

#include “THREAD_TimerUsb.h”

namespace Ui {
class MainWidget;
}

class MainWidget : public QWidget {
Q_OBJECT

private:
QScopedPointerUi::MainWidget ui;

private:
TimerUsb m_usb;

public:
explicit MainWidget(QWidget *parent = nullptr);
~MainWidget();

private:
void show_usbDeviceMsgAll();
void start_work();
};

#endif // FORM_H_27453073957

**WIDGET\_Main.cpp**

#include “WIDGET_Main.h”

#include
#include
#include
#include

#include “ui_WIDGET_Main.h”
#include “usb/USB_Reset.h”

QWidget *g_widgetDisplayBoard = nullptr;
QtMessageHandler g_oldMessageHandler = nullptr;
QMutex g_dispalyMutex;

/**
* debug 重定向
*/
void newDebugHandlerFunc(QtMsgType type, const QMessageLogContext &context, const QString &msg) {
QMutexLocker locker(&g_dispalyMutex);
if (g_widgetDisplayBoard) {
dynamic_cast<QTextEdit *>(g_widgetDisplayBoard)->append(msg);
} else {
g_oldMessageHandler(type, context, msg);
}
}

/**
* @brief MainWidget::MainWidget
* @param parent
* 1. debug重定向
* 2. connect
*/
MainWidget::MainWidget(QWidget *parent) : QWidget(parent), ui(new Ui::MainWidget{}) {
ui->setupUi(this);
setWindowTitle(“usb controller”);

/// debug -> widget
{
    g_widgetDisplayBoard       = ui->textEdit;
    g_oldMessageHandler = qInstallMessageHandler(newDebugHandlerFunc);
}

/// connect
{
    connect(ui->btn_showAll, &QPushButton::clicked, this,
            &MainWidget::show_usbDeviceMsgAll);
    connect(ui->btn_clear, &QPushButton::clicked, ui->textEdit,
            &QTextEdit::clear);
    connect(ui->btn_start, &QPushButton::clicked, this,
            &MainWidget::start_work);

    connect(&m_usb, &TimerUsb::signal_message, this,
            [](const QString &msg) { qInfo() << msg; });
}

/// before exe
{ show\_usbDeviceMsgAll(); }

}

/**
* @brief MainWidget::~MainWidget
* 将线程安全关闭
*/
MainWidget::~MainWidget() {
if (m_usb.isRunning()) {
m_usb.quit();
m_usb.wait();
}
}

/**
* @brief MainWidget::show_usbDeviceMsgAll
* 展示所有usb设备的信息
* 因为设计的是通用库
* 因此返回的是std::vectorstd::string
*/
void MainWidget::show_usbDeviceMsgAll() {
for (auto &&s : USB::Reset().Show_device()) {
qDebug() << s.c_str();
}
}

/**
* @brief MainWidget::start_work
* 检测线程启动
*/
void MainWidget::start_work() {
uint vendor = ui->edit_Vendor->text().toUInt();
double time = ui->edit_timeout->text().toDouble();
m_usb.Set_usbDeviceVendor(vendor);
m_usb.Set_timerInterval(time * 1000);
m_usb.Set_timerStart();

if (false == m_usb.isRunning()) {
    qDebug() << "=== start before ===";
    m_usb.start();
    qDebug() << "=== start after ===";
}

}

**WIDGET\_Main.ui**

<?xml version="1.0" encoding="UTF-8"?> MainWidget 0 0 726 480 UsbForm 12 8746 12 目标Vendor 12 倒计时（秒） 12 2 18 设备usb列表 18 清空列表

一、网安学习成长路线图

网安所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、网安视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

三、精品网安学习书籍

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

四、网络安全源码合集+工具包

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、网络安全面试题

最后就是大家最关心的网络安全面试题板块

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注网络安全）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

5d.png)

三、精品网安学习书籍

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

四、网络安全源码合集+工具包

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、网络安全面试题

最后就是大家最关心的网络安全面试题板块

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注网络安全）
[外链图片转存中…(img-zSdZLbaO-1713283747054)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！