From 19f46adf03a803abce927dbe2ffb3707295d6c05 Mon Sep 17 00:00:00 2001 From: Kevin Trocolli Date: Fri, 10 Mar 2023 02:46:37 -0500 Subject: [PATCH] es3sec: Finalize dongle emulation --- ferrumhook/dllmain.c | 2 + platform/es3sec.c | 275 +++++++++++++++++++++++++++++-------------- platform/es3sec.h | 4 +- platform/platform.c | 2 +- platform/platform.h | 2 + 5 files changed, 192 insertions(+), 93 deletions(-) diff --git a/ferrumhook/dllmain.c b/ferrumhook/dllmain.c index 08d1357..53bf094 100644 --- a/ferrumhook/dllmain.c +++ b/ferrumhook/dllmain.c @@ -37,6 +37,8 @@ static DWORD CALLBACK ferrum_pre_startup(void) struct dongle_info dinfo; dinfo.vid = 2970; dinfo.pid = 3088; + wcscpy_s(dinfo.manufacturer, _countof(L"BM"), L"BM"); + wcscpy_s(dinfo.product, _countof(L"RUDI04GBN-274713"), L"RUDI04GBN-274713"); hr = platform_hook_init(&ferrum_hook_cfg.platform, PLATFORM_ES3, ferrum_jvs_init, ferrum_hook_mod, dinfo); diff --git a/platform/es3sec.c b/platform/es3sec.c index 0d95c30..6ff8c9b 100644 --- a/platform/es3sec.c +++ b/platform/es3sec.c @@ -10,11 +10,18 @@ #include "util/str.h" #include "es3sec.h" +#define DONGLE_STR_IDX_MANUFACTURER 1 +#define DONGLE_STR_IDX_PRODUCT 2 +#define DONGLE_STR_IDX_SERIAL_NUMBER 3 + static const wchar_t DEVNAME_HUB[] = L"$hub"; static const wchar_t DEVNAME_HUB_[] = L"\\\\.\\$hub"; static const wchar_t DEVNAME_DONGLE[] = L"$dongle"; -static const wchar_t HUB_DRIVER_KEY[] = L"{36fc9e60-c465-11cf-8056-444553540000}\\0001"; +static const wchar_t HUB_HCD_DRIVER_KEY[] = L"{36fc9e60-c465-11cf-8056-444553540000}\\0001"; +// This is what a real dongle is set to +static const wchar_t HUB_NODE_CONNECTION_DRIVER_KEY[] = L"{c8b76578-d062-4834-0001-f8b6f2162a22}\\0003"; static const wchar_t root_hub_name[] = L"Fake Root Hub"; +static const wchar_t FILLER_LANGIDS[] = L"\uffff\uffff"; static const DEVINST HUB_DEVINST = 573; static const DEVINST DONGLE_DEVINST = 5730; static struct es3sec_config config; @@ -24,21 +31,22 @@ static IID hubs_iid; static DEVINST root_dev_inst; static USHORT dongle_vid; static USHORT dongle_pid; +static wchar_t dongle_mftr[MAX_PATH]; +static wchar_t dongle_product[MAX_PATH]; static HRESULT es3sec_handle_hub_irp(struct irp *irp); static HRESULT es3sec_handle_hub_open(struct irp *irp); static HRESULT es3sec_handle_hub_close(struct irp *irp); static HRESULT es3sec_handle_hub_ioctl(struct irp *irp); -static HRESULT es3sec_handle_dongle_irp(struct irp *irp); -static HRESULT es3sec_handle_dongle_open(struct irp *irp); -static HRESULT es3sec_handle_dongle_close(struct irp *irp); -static HRESULT es3sec_handle_dongle_ioctl(struct irp *irp); static HRESULT es3sec_hub_handle_driverkey(struct irp *irp); static HRESULT es3sec_hub_handle_roothub(struct irp *irp); static HRESULT es3sec_hub_handle_nodeinfo(struct irp *irp); static HRESULT es3sec_hub_connection_info_ex(struct irp *irp); static HRESULT es3sec_hub_descriptor_from_node(struct irp *irp); +static HRESULT es3sec_hub_connection_driver_key_name(struct irp *irp); +static HRESULT es3sec_hub_get_config_descriptor(struct irp *irp, PUSB_DESCRIPTOR_REQUEST req, UCHAR dataRequested); +static HRESULT es3sec_hub_get_string_descriptor(struct irp *irp, PUSB_DESCRIPTOR_REQUEST req, UCHAR dataRequested); static CONFIGRET my_CM_Get_Child(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags); static CONFIGRET (*next_CM_Get_Child)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags); @@ -73,7 +81,7 @@ static const struct hook_symbol cm_syms[] = { }, }; -HRESULT es3sec_hook_init(const struct es3sec_config *cfg, USHORT vid, USHORT pid) +HRESULT es3sec_hook_init(const struct es3sec_config *cfg, USHORT vid, USHORT pid, wchar_t *manufacturer, wchar_t *product) { HRESULT hr; assert(cfg != NULL); @@ -93,9 +101,9 @@ HRESULT es3sec_hook_init(const struct es3sec_config *cfg, USHORT vid, USHORT pid } hr = iohook_push_handler(es3sec_handle_hub_irp); - hr = iohook_push_handler(es3sec_handle_dongle_irp); - if (FAILED(hr)) { + if (FAILED(hr)) + { return hr; } @@ -103,9 +111,11 @@ HRESULT es3sec_hook_init(const struct es3sec_config *cfg, USHORT vid, USHORT pid CM_Locate_DevNodeW(&root_dev_inst, NULL, CM_LOCATE_DEVNODE_NORMAL); - dprintf("ES3 Dongle: init with VID %d PID %d\n", vid, pid); + dprintf("ES3 Dongle: init\tVID %x PID %x\n", vid, pid); dongle_vid = vid; dongle_pid = pid; + wcscpy_s(dongle_mftr, _countof(manufacturer), manufacturer); + wcscpy_s(dongle_product, _countof(product), product); memcpy(&config, cfg, sizeof(*cfg)); return S_OK; @@ -114,21 +124,28 @@ HRESULT es3sec_hook_init(const struct es3sec_config *cfg, USHORT vid, USHORT pid static HRESULT es3sec_handle_hub_irp(struct irp *irp) { assert(irp != NULL); - if (irp->op != IRP_OP_OPEN && irp->fd != hub_fd) { + if (irp->op != IRP_OP_OPEN && irp->fd != hub_fd) + { return iohook_invoke_next(irp); } - switch (irp->op) { - case IRP_OP_OPEN: return es3sec_handle_hub_open(irp); - case IRP_OP_CLOSE: return es3sec_handle_hub_close(irp); - case IRP_OP_IOCTL: return es3sec_handle_hub_ioctl(irp); - default: return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); + switch (irp->op) + { + case IRP_OP_OPEN: + return es3sec_handle_hub_open(irp); + case IRP_OP_CLOSE: + return es3sec_handle_hub_close(irp); + case IRP_OP_IOCTL: + return es3sec_handle_hub_ioctl(irp); + default: + return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); } } static HRESULT es3sec_handle_hub_open(struct irp *irp) { - if (!wstr_ieq(irp->open_filename, DEVNAME_HUB) && !wstr_ieq(irp->open_filename, DEVNAME_HUB_)) { + if (!wstr_ieq(irp->open_filename, DEVNAME_HUB) && !wstr_ieq(irp->open_filename, DEVNAME_HUB_)) + { return iohook_invoke_next(irp); } @@ -149,41 +166,47 @@ static HRESULT es3sec_handle_hub_ioctl(struct irp *irp) case 0x220424: return es3sec_hub_handle_driverkey(irp); case 0x220448: return es3sec_hub_connection_info_ex(irp); case 0x220410: return es3sec_hub_descriptor_from_node(irp); - case 0x220408: + case 0x220420: return es3sec_hub_connection_driver_key_name(irp); + case 0x220408: if (irp->read.nbytes == sizeof(USB_NODE_INFORMATION)) return es3sec_hub_handle_nodeinfo(irp); - - else if (irp->read.nbytes >= sizeof(USB_ROOT_HUB_NAME)) + + else if (irp->read.nbytes >= sizeof(USB_ROOT_HUB_NAME)) return es3sec_hub_handle_roothub(irp); - - else { - dprintf("ES3 Dongle: Bad size for IOCTL %X\n", irp->ioctl); + + else + { + dprintf("ES3 Dongle: Bad size for IOCTL %X\n", irp->ioctl); return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); } - default: dprintf("ES3 Dongle: Unknown hub IOCTL %X\n", irp->ioctl); return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); + default: + dprintf("ES3 Dongle: Unknown hub IOCTL %X\n", irp->ioctl); + return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); } } static HRESULT es3sec_hub_handle_driverkey(struct irp *irp) -{ - size_t size_of_driver_key = sizeof(HUB_DRIVER_KEY); +{ + size_t size_of_driver_key = sizeof(HUB_HCD_DRIVER_KEY); ULONG actual_length = size_of_driver_key + sizeof(USB_ROOT_HUB_NAME); HRESULT hr; - - if (irp->write.nbytes == sizeof(USB_HCD_DRIVERKEY_NAME)) { + + if (irp->write.nbytes == sizeof(USB_HCD_DRIVERKEY_NAME)) + { dprintf("ES3 Dongle: Get Hub Driver Key size\n"); USB_HCD_DRIVERKEY_NAME usb_hcd_driver_key_name; usb_hcd_driver_key_name.ActualLength = actual_length; hr = iobuf_write(&irp->read, &usb_hcd_driver_key_name, sizeof(usb_hcd_driver_key_name)); - - if (FAILED(hr)) { + + if (FAILED(hr)) + { dprintf("ES3 Dongle: iobuf_write failed! %lx\n", hr); } - + return hr; } - + dprintf("ES3 Dongle: Get Hub Driver Key\n"); PUSB_HCD_DRIVERKEY_NAME usb_hcd_driver_key_name = (PUSB_HCD_DRIVERKEY_NAME)malloc(sizeof(USB_HCD_DRIVERKEY_NAME) + actual_length); @@ -191,18 +214,19 @@ static HRESULT es3sec_hub_handle_driverkey(struct irp *irp) errno_t err = wcscpy_s( usb_hcd_driver_key_name->DriverKeyName, - _countof(HUB_DRIVER_KEY), - HUB_DRIVER_KEY - ); + _countof(HUB_HCD_DRIVER_KEY), + HUB_HCD_DRIVER_KEY); - if (err) { + if (err) + { dprintf("ES3 Dongle: es3sec_hub_handle_driverkey wcscpy_s failed with %X", err); return E_FAIL; } hr = iobuf_write(&irp->read, usb_hcd_driver_key_name, actual_length); - if (FAILED(hr)) { + if (FAILED(hr)) + { dprintf("ES3 Dongle: iobuf_write failed! %lx\n", hr); } @@ -260,7 +284,8 @@ static HRESULT es3sec_hub_handle_nodeinfo(struct irp *irp) node_info.u.HubInformation.HubDescriptor.bNumberOfPorts = 1; HRESULT hr = iobuf_write(&irp->read, &node_info, sizeof(node_info)); - if (FAILED(hr)) { + if (FAILED(hr)) + { dprintf("ES3 Dongle: es3sec_hub_handle_nodeinfo iobuf_write failed! 0x%lX\n", hr); } @@ -277,21 +302,24 @@ static HRESULT es3sec_hub_connection_info_ex(struct irp *irp) dprintf("ES3 Dongle: es3sec_hub_connection_info_ex Failed to read IRP %lx\n", hr); return hr; } - + dprintf("ES3 Dongle: Get Hub Connection Info EX\tConnectionIndex %ld\n", conn_info->ConnectionIndex); conn_info->ConnectionStatus = DeviceConnected; conn_info->DeviceIsHub = false; - + conn_info->DeviceDescriptor.idVendor = dongle_vid; conn_info->DeviceDescriptor.idProduct = dongle_pid; conn_info->DeviceDescriptor.bLength = sizeof(conn_info->DeviceDescriptor); + conn_info->DeviceDescriptor.iManufacturer = DONGLE_STR_IDX_MANUFACTURER; + conn_info->DeviceDescriptor.iProduct = DONGLE_STR_IDX_PRODUCT; + conn_info->DeviceDescriptor.iSerialNumber = DONGLE_STR_IDX_SERIAL_NUMBER; hr = iobuf_write(&irp->read, conn_info, irp->read.nbytes); if (FAILED(hr)) { dprintf("ES3 Dongle: es3sec_hub_connection_info_ex Failed to write IRP %lx\n", hr); } - + return hr; } @@ -301,22 +329,24 @@ static HRESULT es3sec_hub_descriptor_from_node(struct irp *irp) UCHAR req_type; UCHAR req_data_requested; PUSB_DESCRIPTOR_REQUEST req = (PUSB_DESCRIPTOR_REQUEST) malloc(irp->write.nbytes); + hr = iobuf_read(&irp->write, req, irp->write.nbytes); - if (FAILED(hr)) { dprintf("ES3 Dongle: es3sec_hub_descriptor_from_node Failed to read IRP %lx\n", hr); return hr; } - + req_type = req->SetupPacket.wValue >> 8; req_data_requested = req->SetupPacket.wValue & 0xFF; - dprintf("ES3 Dongle: Get Hub Descriptor from Node Connection\treq_type %02X req_data_requested %02X\n", req_type, req_data_requested); + switch (req_type) { - case USB_CONFIGURATION_DESCRIPTOR_TYPE: req->Data[2] = irp->write.nbytes - 12; break; - case USB_STRING_DESCRIPTOR_TYPE: break; - default: + case USB_CONFIGURATION_DESCRIPTOR_TYPE: + return es3sec_hub_get_config_descriptor(irp, req, req_data_requested); + case USB_STRING_DESCRIPTOR_TYPE: + return es3sec_hub_get_string_descriptor(irp, req, req_data_requested); + default: dprintf("ES3 Dongle: es3sec_hub_descriptor_from_node Unknown request type %x\n", req_type); - return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); + return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); } hr = iobuf_write(&irp->read, req, irp->read.nbytes); @@ -326,43 +356,108 @@ static HRESULT es3sec_hub_descriptor_from_node(struct irp *irp) return hr; } -static HRESULT es3sec_handle_dongle_irp(struct irp *irp) +static HRESULT es3sec_hub_get_config_descriptor(struct irp *irp, PUSB_DESCRIPTOR_REQUEST req, UCHAR dataRequested) { - assert(irp != NULL); - if (irp->op != IRP_OP_OPEN && irp->fd != dongle_fd) { - return iohook_invoke_next(irp); - } + dprintf("ES3 Dongle: Get Hub Config Descriptor from Node Connection\twLength %d\n", req->SetupPacket.wLength); - switch (irp->op) { - case IRP_OP_OPEN: return es3sec_handle_dongle_open(irp); - case IRP_OP_CLOSE: return es3sec_handle_dongle_close(irp); - case IRP_OP_IOCTL: return es3sec_handle_dongle_ioctl(irp); - default: return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); + PUSB_CONFIGURATION_DESCRIPTOR config = (PUSB_CONFIGURATION_DESCRIPTOR)malloc(sizeof(USB_CONFIGURATION_DESCRIPTOR)); + config->bLength = sizeof(*config); + config->bDescriptorType = USB_CONFIGURATION_DESCRIPTOR_TYPE; + config->wTotalLength = sizeof(*req); + + int cpy = memcpy_s(req->Data, 9, config, sizeof(*config)); + if (cpy) { + dprintf("ES3 Dongle: es3sec_hub_get_config_descriptor memcpy_s failed %d\n", cpy); } + return iobuf_write(&irp->read, req, irp->read.nbytes); } -static HRESULT es3sec_handle_dongle_open(struct irp *irp) +static HRESULT es3sec_hub_get_string_descriptor(struct irp *irp, PUSB_DESCRIPTOR_REQUEST req, UCHAR dataRequested) { - if (!wstr_ieq(irp->open_filename, DEVNAME_DONGLE)) { - return iohook_invoke_next(irp); - } + dprintf("ES3 Dongle: Get Hub String Descriptor from Node Connection\tdataRequested %d\n", dataRequested); + PUSB_STRING_DESCRIPTOR str_desc; + int additional_length = sizeof(FILLER_LANGIDS); + str_desc = (PUSB_STRING_DESCRIPTOR)malloc(sizeof(USB_STRING_DESCRIPTOR) + additional_length); + str_desc->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE; + wcscpy_s(str_desc->bString, _countof(FILLER_LANGIDS), FILLER_LANGIDS); - dprintf("ES3 Dongle: Open dongle\n"); - irp->fd = dongle_fd; - return S_OK; + switch (dataRequested) { + case DONGLE_STR_IDX_MANUFACTURER: + additional_length = sizeof(dongle_mftr); + str_desc = (PUSB_STRING_DESCRIPTOR)realloc(str_desc, sizeof(USB_STRING_DESCRIPTOR) + additional_length); + str_desc->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE; + wcscpy_s(str_desc->bString, _countof(dongle_mftr), dongle_mftr); + break; + case DONGLE_STR_IDX_PRODUCT: + additional_length = sizeof(dongle_product); + str_desc = (PUSB_STRING_DESCRIPTOR)realloc(str_desc, sizeof(USB_STRING_DESCRIPTOR) + additional_length); + str_desc->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE; + wcscpy_s(str_desc->bString, _countof(dongle_product), dongle_product); + break; + case DONGLE_STR_IDX_SERIAL_NUMBER: + additional_length = sizeof(L"000000000000"); + str_desc = (PUSB_STRING_DESCRIPTOR)realloc(str_desc, sizeof(USB_STRING_DESCRIPTOR) + additional_length); + str_desc->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE; + wcscpy_s(str_desc->bString, _countof(config.serial), config.serial); + break; + } + + str_desc->bLength = sizeof(USB_STRING_DESCRIPTOR) + additional_length; + PUSB_DESCRIPTOR_REQUEST resp = (PUSB_DESCRIPTOR_REQUEST)malloc(sizeof(USB_DESCRIPTOR_REQUEST) + sizeof(USB_STRING_DESCRIPTOR) + additional_length); + + int cpy = memcpy_s(resp->Data, sizeof(USB_STRING_DESCRIPTOR) + additional_length, str_desc, sizeof(USB_STRING_DESCRIPTOR) + additional_length); + if (cpy) { + dprintf("ES3 Dongle: es3sec_hub_get_config_descriptor memcpy_s failed %d\n", cpy); + } + return iobuf_write(&irp->read, resp, sizeof(USB_DESCRIPTOR_REQUEST) + sizeof(USB_STRING_DESCRIPTOR) + additional_length); } -static HRESULT es3sec_handle_dongle_close(struct irp *irp) +static HRESULT es3sec_hub_connection_driver_key_name(struct irp *irp) { - dprintf("ES3 Dongle: Close dongle\n"); - return S_OK; -} + size_t size_of_driver_key = sizeof(HUB_NODE_CONNECTION_DRIVER_KEY); + ULONG actual_length = size_of_driver_key + sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME); + HRESULT hr; -static HRESULT es3sec_handle_dongle_ioctl(struct irp *irp) -{ - switch (irp->ioctl) { - default: dprintf("ES3 Dongle: Unknown dongle IOCTL %X\n", irp->ioctl); return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); + if (irp->write.nbytes == sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME)) + { + dprintf("ES3 Dongle: Get Hub Connection Driver Key size\n"); + USB_NODE_CONNECTION_DRIVERKEY_NAME usb_node_conn_driver_key_name; + usb_node_conn_driver_key_name.ActualLength = actual_length; + hr = iobuf_write(&irp->read, &usb_node_conn_driver_key_name, sizeof(usb_node_conn_driver_key_name)); + + if (FAILED(hr)) + { + dprintf("ES3 Dongle: iobuf_write failed! %lx\n", hr); + } + + return hr; } + + dprintf("ES3 Dongle: Get Hub Connection Driver Key\n"); + + PUSB_NODE_CONNECTION_DRIVERKEY_NAME usb_node_conn_driver_key_name = (PUSB_NODE_CONNECTION_DRIVERKEY_NAME)malloc(sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME) + actual_length); + usb_node_conn_driver_key_name->ConnectionIndex = 1; + usb_node_conn_driver_key_name->ActualLength = actual_length; + + errno_t err = wcscpy_s( + usb_node_conn_driver_key_name->DriverKeyName, + _countof(HUB_NODE_CONNECTION_DRIVER_KEY), + HUB_NODE_CONNECTION_DRIVER_KEY); + + if (err) + { + dprintf("ES3 Dongle: es3sec_hub_connection_driver_key_name wcscpy_s failed with %X", err); + return E_FAIL; + } + + hr = iobuf_write(&irp->read, usb_node_conn_driver_key_name, actual_length); + + if (FAILED(hr)) + { + dprintf("ES3 Dongle: iobuf_write failed! %lx\n", hr); + } + + return hr; } static CONFIGRET my_CM_Get_DevNode_Registry_PropertyW( @@ -371,29 +466,30 @@ static CONFIGRET my_CM_Get_DevNode_Registry_PropertyW( PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, - ULONG ulFlags -) + ULONG ulFlags) { CONFIGRET cr = next_CM_Get_DevNode_Registry_PropertyW(dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, ulFlags); - if (dnDevInst != HUB_DEVINST) { + if (dnDevInst != HUB_DEVINST) + { return cr; } - switch (ulProperty) { - case CM_DRP_DEVICEDESC: - dprintf("ES3 Dongle: Get hub device description\n"); - // wcscpy_s(Buffer, _countof(L"Disk drive"), L"Disk drive"); - wcscpy_s(Buffer, _countof(L"Fake USB Hub"), L"Fake USB Hub"); - break; + switch (ulProperty) + { + case CM_DRP_DEVICEDESC: + dprintf("ES3 Dongle: Get hub device description\n"); + // wcscpy_s(Buffer, _countof(L"Disk drive"), L"Disk drive"); + wcscpy_s(Buffer, _countof(L"Fake USB Hub"), L"Fake USB Hub"); + break; - case CM_DRP_DRIVER: - dprintf("ES3 Dongle: Get hub driver\n"); - wcscpy_s(Buffer, _countof(HUB_DRIVER_KEY), HUB_DRIVER_KEY); - break; + case CM_DRP_DRIVER: + dprintf("ES3 Dongle: Get hub driver\n"); + wcscpy_s(Buffer, _countof(HUB_HCD_DRIVER_KEY), HUB_HCD_DRIVER_KEY); + break; - default: - dprintf("ES3 Dongle: my_CM_Get_DevNode_Registry_PropertyW Unhandled property 0x%lX\n", ulProperty); - return CR_FAILURE; + default: + dprintf("ES3 Dongle: my_CM_Get_DevNode_Registry_PropertyW Unhandled property 0x%lX\n", ulProperty); + return CR_FAILURE; } return CR_SUCCESS; @@ -401,7 +497,8 @@ static CONFIGRET my_CM_Get_DevNode_Registry_PropertyW( static CONFIGRET my_CM_Get_Child(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) { - if (dnDevInst != root_dev_inst) { + if (dnDevInst != root_dev_inst) + { return next_CM_Get_Child(pdnDevInst, dnDevInst, ulFlags); } diff --git a/platform/es3sec.h b/platform/es3sec.h index 862962e..107c42e 100644 --- a/platform/es3sec.h +++ b/platform/es3sec.h @@ -5,8 +5,6 @@ struct es3sec_config { bool enable; wchar_t serial[13]; - wchar_t vid[5]; - wchar_t pid[5]; }; -HRESULT es3sec_hook_init(const struct es3sec_config *cfg, USHORT vid, USHORT pid); +HRESULT es3sec_hook_init(const struct es3sec_config *cfg, USHORT vid, USHORT pid, wchar_t *manufacturer, wchar_t *product); diff --git a/platform/platform.c b/platform/platform.c index 2805ff5..24afb78 100644 --- a/platform/platform.c +++ b/platform/platform.c @@ -57,7 +57,7 @@ HRESULT platform_hook_init( return hr; } - hr = es3sec_hook_init(&cfg->dongle, d_info.vid, d_info.pid); + hr = es3sec_hook_init(&cfg->dongle, d_info.vid, d_info.pid, d_info.manufacturer, d_info.product); if (FAILED(hr)) { return hr; diff --git a/platform/platform.h b/platform/platform.h index 1c0b503..050878d 100644 --- a/platform/platform.h +++ b/platform/platform.h @@ -12,6 +12,8 @@ struct dongle_info { USHORT pid; USHORT vid; + wchar_t manufacturer[MAX_PATH]; + wchar_t product[MAX_PATH]; }; struct platform_config {