Hay1tsme
/
bananatools
3
3
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

es3sec: Finalize dongle emulation

This commit is contained in:
Hay1tsme 2023-03-10 02:46:37 -05:00
parent 4ba5d8c530
commit 19f46adf03
5 changed files with 192 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ferrumhook/dllmain.c
View File

@ -37,6 +37,8 @@ static DWORD CALLBACK ferrum_pre_startup(void)
struct dongle_info dinfo; struct dongle_info dinfo;
dinfo.vid = 2970; dinfo.vid = 2970;
dinfo.pid = 3088; 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); hr = platform_hook_init(&ferrum_hook_cfg.platform, PLATFORM_ES3, ferrum_jvs_init, ferrum_hook_mod, dinfo);

275
platform/es3sec.c
View File

@ -10,11 +10,18 @@
#include "util/str.h" #include "util/str.h"
#include "es3sec.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_HUB_[] = L"\\\\.\\$hub"; static const wchar_t DEVNAME_HUB_[] = L"\\\\.\\$hub";
static const wchar_t DEVNAME_DONGLE[] = L"$dongle"; 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 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 HUB_DEVINST = 573;
static const DEVINST DONGLE_DEVINST = 5730; static const DEVINST DONGLE_DEVINST = 5730;
static struct es3sec_config config; static struct es3sec_config config;
@ -24,21 +31,22 @@ static IID hubs_iid;
static DEVINST root_dev_inst; static DEVINST root_dev_inst;
static USHORT dongle_vid; static USHORT dongle_vid;
static USHORT dongle_pid; 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_irp(struct irp *irp);
static HRESULT es3sec_handle_hub_open(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_close(struct irp *irp);
static HRESULT es3sec_handle_hub_ioctl(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_driverkey(struct irp *irp);
static HRESULT es3sec_hub_handle_roothub(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_handle_nodeinfo(struct irp *irp);
static HRESULT es3sec_hub_connection_info_ex(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_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 my_CM_Get_Child(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
static CONFIGRET (*next_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; HRESULT hr;
assert(cfg != NULL); 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_hub_irp);
hr = iohook_push_handler(es3sec_handle_dongle_irp);
if (FAILED(hr)) { if (FAILED(hr))
{
return 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); 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_vid = vid;
dongle_pid = pid; dongle_pid = pid;
wcscpy_s(dongle_mftr, _countof(manufacturer), manufacturer);
wcscpy_s(dongle_product, _countof(product), product);
memcpy(&config, cfg, sizeof(*cfg)); memcpy(&config, cfg, sizeof(*cfg));
return S_OK; 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) static HRESULT es3sec_handle_hub_irp(struct irp *irp)
{ {
assert(irp != NULL); 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); return iohook_invoke_next(irp);
} }
switch (irp->op) { 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_OPEN:
case IRP_OP_IOCTL: return es3sec_handle_hub_ioctl(irp); return es3sec_handle_hub_open(irp);
default: return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); 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) 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); 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 0x220424: return es3sec_hub_handle_driverkey(irp);
case 0x220448: return es3sec_hub_connection_info_ex(irp); case 0x220448: return es3sec_hub_connection_info_ex(irp);
case 0x220410: return es3sec_hub_descriptor_from_node(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)) if (irp->read.nbytes == sizeof(USB_NODE_INFORMATION))
return es3sec_hub_handle_nodeinfo(irp); 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); return es3sec_hub_handle_roothub(irp);
else { else
dprintf("ES3 Dongle: Bad size for IOCTL %X\n", irp->ioctl); {
dprintf("ES3 Dongle: Bad size for IOCTL %X\n", irp->ioctl);
return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); 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) 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); ULONG actual_length = size_of_driver_key + sizeof(USB_ROOT_HUB_NAME);
HRESULT hr; 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"); dprintf("ES3 Dongle: Get Hub Driver Key size\n");
USB_HCD_DRIVERKEY_NAME usb_hcd_driver_key_name; USB_HCD_DRIVERKEY_NAME usb_hcd_driver_key_name;
usb_hcd_driver_key_name.ActualLength = actual_length; usb_hcd_driver_key_name.ActualLength = actual_length;
hr = iobuf_write(&irp->read, &usb_hcd_driver_key_name, sizeof(usb_hcd_driver_key_name)); 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); dprintf("ES3 Dongle: iobuf_write failed! %lx\n", hr);
} }
return hr; return hr;
} }
dprintf("ES3 Dongle: Get Hub Driver Key\n"); 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); 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( errno_t err = wcscpy_s(
usb_hcd_driver_key_name->DriverKeyName, usb_hcd_driver_key_name->DriverKeyName,
_countof(HUB_DRIVER_KEY), _countof(HUB_HCD_DRIVER_KEY),
HUB_DRIVER_KEY HUB_HCD_DRIVER_KEY);
);
if (err) { if (err)
{
dprintf("ES3 Dongle: es3sec_hub_handle_driverkey wcscpy_s failed with %X", err); dprintf("ES3 Dongle: es3sec_hub_handle_driverkey wcscpy_s failed with %X", err);
return E_FAIL; return E_FAIL;
} }
hr = iobuf_write(&irp->read, usb_hcd_driver_key_name, actual_length); 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); 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; node_info.u.HubInformation.HubDescriptor.bNumberOfPorts = 1;
HRESULT hr = iobuf_write(&irp->read, &node_info, sizeof(node_info)); 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); 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); dprintf("ES3 Dongle: es3sec_hub_connection_info_ex Failed to read IRP %lx\n", hr);
return hr; return hr;
} }
dprintf("ES3 Dongle: Get Hub Connection Info EX\tConnectionIndex %ld\n", conn_info->ConnectionIndex); dprintf("ES3 Dongle: Get Hub Connection Info EX\tConnectionIndex %ld\n", conn_info->ConnectionIndex);
conn_info->ConnectionStatus = DeviceConnected; conn_info->ConnectionStatus = DeviceConnected;
conn_info->DeviceIsHub = false; conn_info->DeviceIsHub = false;
conn_info->DeviceDescriptor.idVendor = dongle_vid; conn_info->DeviceDescriptor.idVendor = dongle_vid;
conn_info->DeviceDescriptor.idProduct = dongle_pid; conn_info->DeviceDescriptor.idProduct = dongle_pid;
conn_info->DeviceDescriptor.bLength = sizeof(conn_info->DeviceDescriptor); 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); hr = iobuf_write(&irp->read, conn_info, irp->read.nbytes);
if (FAILED(hr)) { if (FAILED(hr)) {
dprintf("ES3 Dongle: es3sec_hub_connection_info_ex Failed to write IRP %lx\n", hr); dprintf("ES3 Dongle: es3sec_hub_connection_info_ex Failed to write IRP %lx\n", hr);
} }
return hr; return hr;
} }
@ -301,22 +329,24 @@ static HRESULT es3sec_hub_descriptor_from_node(struct irp *irp)
UCHAR req_type; UCHAR req_type;
UCHAR req_data_requested; UCHAR req_data_requested;
PUSB_DESCRIPTOR_REQUEST req = (PUSB_DESCRIPTOR_REQUEST) malloc(irp->write.nbytes); PUSB_DESCRIPTOR_REQUEST req = (PUSB_DESCRIPTOR_REQUEST) malloc(irp->write.nbytes);
hr = iobuf_read(&irp->write, req, irp->write.nbytes); hr = iobuf_read(&irp->write, req, irp->write.nbytes);
if (FAILED(hr)) { if (FAILED(hr)) {
dprintf("ES3 Dongle: es3sec_hub_descriptor_from_node Failed to read IRP %lx\n", hr); dprintf("ES3 Dongle: es3sec_hub_descriptor_from_node Failed to read IRP %lx\n", hr);
return hr; return hr;
} }
req_type = req->SetupPacket.wValue >> 8; req_type = req->SetupPacket.wValue >> 8;
req_data_requested = req->SetupPacket.wValue & 0xFF; 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) { switch (req_type) {
case USB_CONFIGURATION_DESCRIPTOR_TYPE: req->Data[2] = irp->write.nbytes - 12; break; case USB_CONFIGURATION_DESCRIPTOR_TYPE:
case USB_STRING_DESCRIPTOR_TYPE: break; return es3sec_hub_get_config_descriptor(irp, req, req_data_requested);
default: 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); 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); 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; 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); dprintf("ES3 Dongle: Get Hub Config Descriptor from Node Connection\twLength %d\n", req->SetupPacket.wLength);
if (irp->op != IRP_OP_OPEN && irp->fd != dongle_fd) {
return iohook_invoke_next(irp);
}
switch (irp->op) { PUSB_CONFIGURATION_DESCRIPTOR config = (PUSB_CONFIGURATION_DESCRIPTOR)malloc(sizeof(USB_CONFIGURATION_DESCRIPTOR));
case IRP_OP_OPEN: return es3sec_handle_dongle_open(irp); config->bLength = sizeof(*config);
case IRP_OP_CLOSE: return es3sec_handle_dongle_close(irp); config->bDescriptorType = USB_CONFIGURATION_DESCRIPTOR_TYPE;
case IRP_OP_IOCTL: return es3sec_handle_dongle_ioctl(irp); config->wTotalLength = sizeof(*req);
default: return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION);
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)) { dprintf("ES3 Dongle: Get Hub String Descriptor from Node Connection\tdataRequested %d\n", dataRequested);
return iohook_invoke_next(irp); 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"); switch (dataRequested) {
irp->fd = dongle_fd; case DONGLE_STR_IDX_MANUFACTURER:
return S_OK; 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"); size_t size_of_driver_key = sizeof(HUB_NODE_CONNECTION_DRIVER_KEY);
return S_OK; ULONG actual_length = size_of_driver_key + sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME);
} HRESULT hr;
static HRESULT es3sec_handle_dongle_ioctl(struct irp *irp) if (irp->write.nbytes == sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME))
{ {
switch (irp->ioctl) { dprintf("ES3 Dongle: Get Hub Connection Driver Key size\n");
default: dprintf("ES3 Dongle: Unknown dongle IOCTL %X\n", irp->ioctl); return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION); 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( static CONFIGRET my_CM_Get_DevNode_Registry_PropertyW(
@ -371,29 +466,30 @@ static CONFIGRET my_CM_Get_DevNode_Registry_PropertyW(
PULONG pulRegDataType, PULONG pulRegDataType,
PVOID Buffer, PVOID Buffer,
PULONG pulLength, PULONG pulLength,
ULONG ulFlags ULONG ulFlags)
)
{ {
CONFIGRET cr = next_CM_Get_DevNode_Registry_PropertyW(dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, 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; return cr;
} }
switch (ulProperty) { switch (ulProperty)
case CM_DRP_DEVICEDESC: {
dprintf("ES3 Dongle: Get hub device description\n"); case CM_DRP_DEVICEDESC:
// wcscpy_s(Buffer, _countof(L"Disk drive"), L"Disk drive"); dprintf("ES3 Dongle: Get hub device description\n");
wcscpy_s(Buffer, _countof(L"Fake USB Hub"), L"Fake USB Hub"); // wcscpy_s(Buffer, _countof(L"Disk drive"), L"Disk drive");
break; wcscpy_s(Buffer, _countof(L"Fake USB Hub"), L"Fake USB Hub");
break;
case CM_DRP_DRIVER: case CM_DRP_DRIVER:
dprintf("ES3 Dongle: Get hub driver\n"); dprintf("ES3 Dongle: Get hub driver\n");
wcscpy_s(Buffer, _countof(HUB_DRIVER_KEY), HUB_DRIVER_KEY); wcscpy_s(Buffer, _countof(HUB_HCD_DRIVER_KEY), HUB_HCD_DRIVER_KEY);
break; break;
default: default:
dprintf("ES3 Dongle: my_CM_Get_DevNode_Registry_PropertyW Unhandled property 0x%lX\n", ulProperty); dprintf("ES3 Dongle: my_CM_Get_DevNode_Registry_PropertyW Unhandled property 0x%lX\n", ulProperty);
return CR_FAILURE; return CR_FAILURE;
} }
return CR_SUCCESS; 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) 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); return next_CM_Get_Child(pdnDevInst, dnDevInst, ulFlags);
} }

4
platform/es3sec.h
View File

@ -5,8 +5,6 @@
struct es3sec_config { struct es3sec_config {
bool enable; bool enable;
wchar_t serial[13]; 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);

2
platform/platform.c
View File

@ -57,7 +57,7 @@ HRESULT platform_hook_init(
return hr; 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)) { if (FAILED(hr)) {
return hr; return hr;

2
platform/platform.h
View File

@ -12,6 +12,8 @@
struct dongle_info { struct dongle_info {
USHORT pid; USHORT pid;
USHORT vid; USHORT vid;
wchar_t manufacturer[MAX_PATH];
wchar_t product[MAX_PATH];
}; };
struct platform_config { struct platform_config {