diff --git a/device/gxx-linux/usb/src/common/encrypt.cpp b/device/gxx-linux/usb/src/common/encrypt.cpp index 8a2afad..2bcb000 100644 --- a/device/gxx-linux/usb/src/common/encrypt.cpp +++ b/device/gxx-linux/usb/src/common/encrypt.cpp @@ -24,40 +24,108 @@ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // exporting api: -dyn_mem_ptr packet_encrypt(LPPACK_BASE packet, uint8_t* data, size_t size, uint32_t cmd_type, uint32_t type, uint8_t enc_data) +dyn_mem_ptr packet_encrypt(dyn_mem_ptr packet, uint32_t cmd_type, uint32_t type, uint8_t enc_data) { - dyn_mem_ptr ret = nullptr; + dyn_mem_ptr ret = packet; + LPPACK_BASE pack = (LPPACK_BASE)packet->ptr(); + ret->add_ref(); if (cmd_type == ENCRYPT_CMD_XOR_PID) - packet->cmd ^= packet->pack_id; + pack->cmd ^= pack->pack_id; else if (cmd_type == ENCRYPT_CMD_ADD_PID) - packet->cmd += packet->pack_id; + pack->cmd += pack->pack_id; else if (cmd_type == ENCRYPT_CMD_SUB_PID) - packet->cmd -= packet->pack_id; + pack->cmd -= pack->pack_id; - packet->enc_cmd = cmd_type; - packet->encrypt = type; - packet->enc_data = enc_data; - if (data && size == 0 && type != ENCRYPT_NONE) + pack->enc_cmd = cmd_type; + if (type != ENCRYPT_NONE) { + std::string cont(""); + if (type == ENCRYPT_BASE64) + { + + } + else if (type == ENCRYPT_AES) + { + + } + else if (type == ENCRYPT_ZIP) + { + + } + + if (cont.length()) + { + // space is enough ? + if (cont.length() + sizeof(PACK_BASE) > packet->space()) + { + ret->release(); + ret = dyn_mem::memory(sizeof(PACK_BASE) + cont.length()); + memcpy(ret->ptr(), packet->ptr(), sizeof(PACK_BASE)); + pack = (LPPACK_BASE)ret->ptr(); + } + + // copy cipher text and set encrypt type ... + memcpy(pack->payload, cont.c_str(), cont.length()); + ret->set_len(sizeof(PACK_BASE) + cont.length()); + pack->payload_len = cont.length(); + pack->encrypt = type; + pack->enc_data = enc_data; + } } return ret; } -dyn_mem_ptr packet_decrypt(LPPACK_BASE packet, uint8_t* data, size_t size) +dyn_mem_ptr packet_decrypt(dyn_mem_ptr packet) { - dyn_mem_ptr ret = nullptr; + dyn_mem_ptr ret = packet; + LPPACK_BASE pack = (LPPACK_BASE)packet->ptr(); - if (packet->enc_cmd == ENCRYPT_CMD_XOR_PID) - packet->cmd ^= packet->pack_id; - else if (packet->enc_cmd == ENCRYPT_CMD_ADD_PID) - packet->cmd -= packet->pack_id; - else if (packet->enc_cmd == ENCRYPT_CMD_SUB_PID) - packet->cmd += packet->pack_id; + ret->add_ref(); + if (pack->enc_cmd == ENCRYPT_CMD_XOR_PID) + pack->cmd ^= pack->pack_id; + else if (pack->enc_cmd == ENCRYPT_CMD_ADD_PID) + pack->cmd -= pack->pack_id; + else if (pack->enc_cmd == ENCRYPT_CMD_SUB_PID) + pack->cmd += pack->pack_id; - if (data && size && packet->encrypt != ENCRYPT_NONE) + if (pack->encrypt != ENCRYPT_NONE && pack->payload_len && packet->get_rest() >= sizeof(PACK_BASE) + pack->payload_len) { + std::string cont(""); + if (pack->encrypt == ENCRYPT_BASE64) + { + } + else if (pack->encrypt == ENCRYPT_AES) + { + + } + else if (pack->encrypt == ENCRYPT_ZIP) + { + + } + + if (cont.length()) + { + // have out-packet data ? + if (packet->get_rest() > sizeof(PACK_BASE) + pack->payload_len) + cont += std::string(pack->payload + pack->payload_len, packet->get_rest() - (sizeof(PACK_BASE) + pack->payload_len)); + + // space is enough ? + if (cont.length() + sizeof(PACK_BASE) > packet->space()) + { + ret->release(); + ret = dyn_mem::memory(sizeof(PACK_BASE) + cont.length()); + memcpy(ret->ptr(), packet->ptr(), sizeof(PACK_BASE)); + pack = (LPPACK_BASE)ret->ptr(); + } + + // copy plain text and set encrypt type to none ... + memcpy(pack->payload, cont.c_str(), cont.length()); + ret->set_len(sizeof(PACK_BASE) + cont.length()); + pack->encrypt = ENCRYPT_NONE; + pack->payload_len = cont.length(); + } } return ret; diff --git a/device/gxx-linux/usb/src/common/encrypt.h b/device/gxx-linux/usb/src/common/encrypt.h index 68399ae..97d427f 100644 --- a/device/gxx-linux/usb/src/common/encrypt.h +++ b/device/gxx-linux/usb/src/common/encrypt.h @@ -42,5 +42,5 @@ enum encrypt_cmd // // NOTE: nullptr also returned if data was nullptr or size was ZERO // -dyn_mem_ptr packet_encrypt(LPPACK_BASE packet, uint8_t* data, size_t size, uint32_t cmd_type = ENCRYPT_CMD_NONE, uint32_t type = ENCRYPT_NONE, uint8_t enc_data = 0); -dyn_mem_ptr packet_decrypt(LPPACK_BASE packet, uint8_t* data, size_t size); +dyn_mem_ptr packet_encrypt(dyn_mem_ptr packet, uint32_t cmd_type = ENCRYPT_CMD_NONE, uint32_t type = ENCRYPT_NONE, uint8_t enc_data = 0); +dyn_mem_ptr packet_decrypt(dyn_mem_ptr packet); diff --git a/device/gxx-linux/usb/src/common/packet.h b/device/gxx-linux/usb/src/common/packet.h index 4e337a0..4b32513 100644 --- a/device/gxx-linux/usb/src/common/packet.h +++ b/device/gxx-linux/usb/src/common/packet.h @@ -36,6 +36,7 @@ enum ep0_req USB_REQ_EP0_GET_STATUS, // 获取各工作线程状态, return EP0REPLYSTATUS. req = me, ind = 0, val = 0, len = sizeof(EP0REPLYSTATUS) USB_REQ_EP0_RESET_BULK, // 关闭并重新打开BULK端点, return error number (uint32_t). req = me, ind = 0, val = 0, len = sizeof(uint32_t) USB_REQ_EP0_CANCEL_CMD, // 取消当前指令的继续执行（一般用于中止大数据的传输）. req = me, ind = 0, val = 0, len = sizeof(uint32_t) * 2 [(uint32_t)cmd + (uint32_t)pack-id] + USB_REQ_EP0_SET_ENCRYPT, // 设置加密方式， req = me, ind = 0, val = 0, len = sizeof(PACK_BASE) }; enum bulk_status { @@ -77,7 +78,7 @@ enum packet_cmd PACK_CMD_SCAN_BASE = 200, PAIR_COMMAND(PACK_CMD_SCAN_START), // start scanning, [in]: PACK_BASE, [out]: PACK_BASE PAIR_COMMAND(PACK_CMD_SCAN_IMG), // device -> host, PACK_BASE::payload - LPPACKIMAGE - PACK_CMD_SCAN_FINISHED_ROGER, // device -> host, PACK_BASE + PACK_CMD_SCAN_FINISHED_ROGER, // device -> host, PACK_BASE::data is scanner_status PAIR_COMMAND(PACK_CMD_SCAN_STOP), // stop scanning, [in]: PACK_BASE, [out]: PACK_BASE //PAIR_COMMAND(PACK_CMD_SCAN_IMAGE_REQ), // get image request, [in]: PACK_BASE, [out] PACK_BASE on error, or PACK_BASE::payload - LPPACKIMAGE //PAIR_COMMAND(PACK_CMD_SCAN_STATUS), // get scanner status, [in]: PACK_BASE, [out] PACK_BASE::result is status code @@ -103,7 +104,7 @@ enum packet_cmd enum scanner_status { - SCANNER_STATUS_READY = 0, + SCANNER_STATUS_READY = 0x10000, // status beginning, avoiding conficts with standards/system error code SCANNER_STATUS_NOT_OPEN, SCANNER_STATUS_LOST_CONNECT, SCANNER_STATUS_RESET_BULK, diff --git a/device/gxx-linux/usb/src/common/usb_io.cpp b/device/gxx-linux/usb/src/common/usb_io.cpp index 81f7b32..766db8e 100644 --- a/device/gxx-linux/usb/src/common/usb_io.cpp +++ b/device/gxx-linux/usb/src/common/usb_io.cpp @@ -7,6 +7,7 @@ #include "../../inc/logs_out.h" #include "sys_util.h" #include "log_util.h" +#include "encrypt.h" // #define TEST @@ -48,6 +49,7 @@ usb_gadget* usb_gadget_config::get_config(void) async_usb_gadget::async_usb_gadget(usb_gadget* gadget, std::function unhandled_ep0 , std::function cmd_handler) : gadget_(gadget), unhandled_ep0_(unhandled_ep0), handle_cmd_(cmd_handler), threads_(new thread_pool(this)) + , enc_head_(ENCRYPT_CMD_NONE), enc_payload_(ENCRYPT_NONE), enc_data_(0) { wait_ep0_ = new linux_event("wait_ep0"); memset((void*)&status_, 0, sizeof(status_)); @@ -301,6 +303,16 @@ dyn_mem_ptr async_usb_gadget::handle_ctrl_setup(dyn_mem_ptr data) err = EBUSY; reply->put(&err, sizeof(err)); break; + case USB_REQ_EP0_SET_ENCRYPT: + if (pev->u.setup.wLength == sizeof(PACK_BASE)) + { + LPPACK_BASE pack = (LPPACK_BASE)&pev[1]; + enc_head_ = pack->enc_cmd; + enc_payload_ = pack->encrypt; + enc_data_ = pack->enc_data; + log_cls::log(LOG_LEVEL_DEBUG, "Set encrypting method: command - %d; payload - %d\n", enc_head_, enc_payload_); + } + break; default: handled = false; } @@ -382,6 +394,25 @@ int async_usb_gadget::inner_write_bulk(data_source_ptr data, int* err) return off; } +dyn_mem_ptr async_usb_gadget::handle_bulk_command(dyn_mem_ptr data, uint32_t* used, packet_data_base_ptr* pkd) +{ + dyn_mem_ptr decrypt = packet_decrypt(data); + + if (decrypt) + { + data->release(); + data = decrypt; + + return handle_cmd_(data, used, pkd); + } + else + { + *used = data->get_rest(); + *pkd = nullptr; + + return nullptr; + } +} void async_usb_gadget::thread_check_ep0_status(void) { @@ -664,7 +695,7 @@ void async_usb_gadget::thread_pump_task(void) status_.task_cmd = pack->cmd; status_.task_pack_id = pack->pack_id; used = data->get_rest(); - reply = handle_cmd_(data, &used, &pack_data); + reply = handle_bulk_command(data, &used, &pack_data); if(pack_data) { dh = dynamic_cast(pack_data); @@ -728,6 +759,14 @@ void async_usb_gadget::thread_pump_task(void) // first reply the packet ... if(reply) { + // encrypt ... + dyn_mem_ptr enc = packet_encrypt(reply, enc_head_, enc_payload_, enc_data_); + if (enc) + { + reply->release(); + reply = enc; + } + write_bulk(dynamic_cast(reply)); reply->release(); reply = nullptr; diff --git a/device/gxx-linux/usb/src/common/usb_io.h b/device/gxx-linux/usb/src/common/usb_io.h index 1b1c863..261516c 100644 --- a/device/gxx-linux/usb/src/common/usb_io.h +++ b/device/gxx-linux/usb/src/common/usb_io.h @@ -77,6 +77,10 @@ class async_usb_gadget : public refer int thread_bulk_in_id_ = -1; int thread_bulk_out_id_ = -1; int thread_restart_id_ = -1; + uint32_t enc_head_; + uint32_t enc_payload_; + uint8_t enc_data_; + volatile EP0REPLYSTATUS status_; safe_fifo cmd_que_; safe_fifo sent_que_; @@ -111,6 +115,7 @@ class async_usb_gadget : public refer int handle_ctrl_message(dyn_mem_ptr data); dyn_mem_ptr handle_ctrl_setup(dyn_mem_ptr data); // user command ... int inner_write_bulk(data_source_ptr data, int* err = nullptr); + dyn_mem_ptr handle_bulk_command(dyn_mem_ptr data, uint32_t* used, packet_data_base_ptr* pkd); void thread_check_ep0_status(void); void thread_read_ep0(void); diff --git a/pc/code_twain/sln/usb_tools/Debug/usb_tools.exe b/pc/code_twain/sln/usb_tools/Debug/usb_tools.exe index 2f715ce..9257c3e 100644 Binary files a/pc/code_twain/sln/usb_tools/Debug/usb_tools.exe and b/pc/code_twain/sln/usb_tools/Debug/usb_tools.exe differ diff --git a/pc/code_twain/sln/usb_tools/scanner/scanner_handler.cpp b/pc/code_twain/sln/usb_tools/scanner/scanner_handler.cpp index 9e7befb..edc1f61 100644 --- a/pc/code_twain/sln/usb_tools/scanner/scanner_handler.cpp +++ b/pc/code_twain/sln/usb_tools/scanner/scanner_handler.cpp @@ -133,7 +133,9 @@ int cmd_result::clean(void) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // scanner_handler -scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_NOT_OPEN), img_receiver_(std::function()) +scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_NOT_OPEN) + , img_receiver_(std::function()) + , status_notify_(std::function()) { auto on_reply = [&](dyn_mem_ptr reply, uint32_t* used, packet_data_base_ptr* more) ->dyn_mem_ptr { @@ -174,7 +176,10 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N else { LPPACKIMAGE pimg = (LPPACKIMAGE)pack->payload; - data_holder_ptr receiver = img_receiver_(pimg, pimg->info_size + pimg->data_size); + data_holder_ptr receiver = nullptr; + + if(img_receiver_) + receiver = img_receiver_(pimg, pimg->info_size + pimg->data_size); if (!receiver) { @@ -188,10 +193,12 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N } else if (pack->cmd == PACK_CMD_SCAN_FINISHED_ROGER) { - data_holder_ptr receiver = img_receiver_(NULL, pack->data); - if (receiver) - receiver->release(); - + if (img_receiver_) + { + data_holder_ptr receiver = img_receiver_(NULL, pack->data); + if (receiver) + receiver->release(); + } *used = sizeof(PACK_BASE); status_ = pack->data; } @@ -199,6 +206,8 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N { *used = sizeof(PACK_BASE); status_ = pack->data; + if (status_notify_) + status_notify_(status_); } else if (pack->cmd == PACK_CMD_FILE_WRITE_REQ_ROGER) { @@ -556,6 +565,10 @@ void scanner_handler::set_image_receiver(std::function stntf) +{ + status_notify_ = stntf; +} int scanner_handler::scan_start(void) { auto call = [&](cmd_result* cmd) -> int @@ -856,6 +869,7 @@ int scanner_handler::open_usb_scanner(libusb_device* dev) ret = usb_->start(dev); if(ret == 0) status_ = SCANNER_STATUS_READY; + //usb_->set_gadget_encrypting_method(ENCRYPT_CMD_XOR_PID); } return ret; diff --git a/pc/code_twain/sln/usb_tools/scanner/scanner_handler.h b/pc/code_twain/sln/usb_tools/scanner/scanner_handler.h index c95eed7..45bca09 100644 --- a/pc/code_twain/sln/usb_tools/scanner/scanner_handler.h +++ b/pc/code_twain/sln/usb_tools/scanner/scanner_handler.h @@ -70,6 +70,7 @@ class scanner_handler : public refer async_usb_host* usb_; volatile uint32_t status_; + std::function status_notify_; std::function img_receiver_; cmd_result* gen_reply(std::function call, @@ -111,6 +112,7 @@ public: int status_get(void); void set_image_receiver(std::function img); + void set_status_notifyer(std::function stntf); int scan_start(void); int scan_stop(void); diff --git a/pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.cpp b/pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.cpp index fd1955d..245c0f6 100644 --- a/pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.cpp +++ b/pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.cpp @@ -6,11 +6,11 @@ - ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // async_usb_host async_usb_host::async_usb_host(std::function cmd_handler) : handler_(cmd_handler), usb_dev_(nullptr), usb_handle_(nullptr), run_(true), cancel_write_(false), writing_(false) + , head_enc_type_(ENCRYPT_CMD_NONE), payload_enc_type_(ENCRYPT_NONE), enc_data_(0) { memset(&bulk_in_, -1, sizeof(bulk_in_)); memset(&bulk_out_, -1, sizeof(bulk_out_)); @@ -59,13 +59,16 @@ int async_usb_host::enum_usb_endpoints(libusb_device* dev, std::vector& e return ret; } -dyn_mem_ptr async_usb_host::base_packet(int cmd, uint32_t id) +dyn_mem_ptr async_usb_host::base_packet(int cmd, uint32_t id, uint32_t encrypt) { - dyn_mem_ptr data(dyn_mem::memory(sizeof(PACK_BASE))); + dyn_mem_ptr data(dyn_mem::memory(sizeof(PACK_BASE))), enc = nullptr; LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); data->set_len(sizeof(PACK_BASE)); BASE_PACKET_REPLY(*pack, cmd, id, 0); + enc = packet_encrypt(data, encrypt); + data->release(); + data = enc; return data; } @@ -177,6 +180,19 @@ int async_usb_host::stop(void) return 0; } +uint32_t& async_usb_host::encrypt_type_packet_head(void) +{ + return head_enc_type_; // = ENCRYPT_CMD_NONE; +} +uint32_t& async_usb_host::encrypt_type_payload(void) +{ + return payload_enc_type_; +} +uint8_t& async_usb_host::encrypt_data(void) +{ + return enc_data_; +} + void async_usb_host::thread_read_bulk(void) { dyn_mem_ptr mem = dyn_mem::memory(bulk_in_.max_packet); @@ -443,9 +459,24 @@ void async_usb_host::post_2_write_bulk_thread(data_source_ptr data) data->add_ref(); out_que_.save(data, true); } -dyn_mem_ptr async_usb_host::handle_data_in(dyn_mem_ptr data, uint32_t* used, packet_data_base_ptr* more) +dyn_mem_ptr async_usb_host::handle_data_in(dyn_mem_ptr& data, uint32_t* used, packet_data_base_ptr* more) { - return handler_(data, used, more); + dyn_mem_ptr decrypt = packet_decrypt(data); + + if (decrypt) + { + data->release(); + data = decrypt; + + return handler_(data, used, more); + } + else + { + *used = data->get_rest(); + *more = nullptr; + + return nullptr; + } } int async_usb_host::get_peer_protocol_version(uint8_t* main, uint8_t* sub) @@ -497,10 +528,27 @@ int async_usb_host::restart_peer_bulk(uint32_t timeout) return err ? err : ok; } +int async_usb_host::set_gadget_encrypting_method(uint32_t cmd_enc, uint32_t payload_enc, uint8_t enc_data) +{ + dyn_mem_ptr ptr(dyn_mem::memory(sizeof(PACK_BASE))); + LPPACK_BASE pack = (LPPACK_BASE)ptr->ptr(); + int err = 0; + + pack->size = sizeof(*pack); + pack->enc_cmd = cmd_enc; + pack->encrypt = payload_enc; + pack->enc_data = enc_data; + err = libusb_control_transfer(usb_handle_, LIBUSB_REQUEST_TYPE_VENDOR, USB_REQ_EP0_SET_ENCRYPT, 0, 0 + , (unsigned char*)pack, sizeof(*pack) + , 1000); + ptr->release(); + + return err; +} int async_usb_host::send_heart_beat(uint32_t pack_id) { - dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_HEART_BEAT, pack_id)); + dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_HEART_BEAT, pack_id, head_enc_type_)); post_2_write_bulk_thread(data); data->release(); @@ -509,7 +557,7 @@ int async_usb_host::send_heart_beat(uint32_t pack_id) } int async_usb_host::get_settings(uint32_t pack_id) { - dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SETTING_GET, pack_id)); + dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SETTING_GET, pack_id, head_enc_type_)); post_2_write_bulk_thread(data); data->release(); @@ -518,13 +566,19 @@ int async_usb_host::get_settings(uint32_t pack_id) } int async_usb_host::get_setting_val(uint32_t pack_id, const char* name) { - dyn_mem_ptr data(dyn_mem::memory(sizeof(PACK_BASE) + strlen(name) + 1)); + dyn_mem_ptr data(dyn_mem::memory(sizeof(PACK_BASE) + strlen(name) + 1)), enc = nullptr; LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); BASE_PACKET_REPLY(*pack, PACK_CMD_SETTING_GET_CUR, pack_id, 0); pack->payload_len = strlen(name) + 1; strcpy(pack->payload, name); data->set_len(sizeof(PACK_BASE) + strlen(name) + 1); + enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_); + if (enc) + { + data->release(); + data = enc; + } post_2_write_bulk_thread(data); data->release(); @@ -534,7 +588,7 @@ int async_usb_host::set_setting(uint32_t pack_id, const char* name, int type, vo { int base = sizeof(PACK_BASE), datal = strlen(name) + 1 + size; - dyn_mem_ptr data(dyn_mem::memory(base + datal)); + dyn_mem_ptr data(dyn_mem::memory(base + datal)), enc = nullptr; LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPCFGVAL param = (LPCFGVAL)pack->payload; @@ -546,6 +600,12 @@ int async_usb_host::set_setting(uint32_t pack_id, const char* name, int type, vo strcpy(param->data, name); memcpy(param->data + param->val_off, val, size); data->set_len(base + datal); + enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_); + if (enc) + { + data->release(); + data = enc; + } post_2_write_bulk_thread(data); data->release(); @@ -554,7 +614,7 @@ int async_usb_host::set_setting(uint32_t pack_id, const char* name, int type, vo int async_usb_host::scan_start(uint32_t pack_id) { - dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SCAN_START, pack_id)); + dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SCAN_START, pack_id, head_enc_type_)); post_2_write_bulk_thread(data); data->release(); @@ -563,7 +623,7 @@ int async_usb_host::scan_start(uint32_t pack_id) } int async_usb_host::scan_stop(uint32_t pack_id) { - dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SCAN_STOP, pack_id)); + dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SCAN_STOP, pack_id, head_enc_type_)); post_2_write_bulk_thread(data); data->release(); @@ -575,7 +635,7 @@ int async_usb_host::file_send(uint32_t pack_id, const char* remote_path, uint64_ { int base = sizeof(PACK_BASE), datal = sizeof(TXFILE) + strlen(remote_path) + 1; - dyn_mem_ptr data = dyn_mem::memory(base + datal); + dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr; LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPTXFILE ptxf = (LPTXFILE)pack->payload; @@ -585,6 +645,12 @@ int async_usb_host::file_send(uint32_t pack_id, const char* remote_path, uint64_ ptxf->size = size; strcpy(ptxf->path, remote_path); data->set_len(base + datal); + enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_); + if (enc) + { + data->release(); + data = enc; + } post_2_write_bulk_thread(data); data->release(); @@ -594,7 +660,7 @@ int async_usb_host::file_get(uint32_t pack_id, const char* remote_path, uint64_t { int base = sizeof(PACK_BASE), datal = sizeof(TXFILE) + strlen(remote_path) + 1; - dyn_mem_ptr data = dyn_mem::memory(base + datal); + dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr; LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPTXFILE ptxf = (LPTXFILE)pack->payload; @@ -604,6 +670,12 @@ int async_usb_host::file_get(uint32_t pack_id, const char* remote_path, uint64_t ptxf->size = 0; strcpy(ptxf->path, remote_path); data->set_len(base + datal); + enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_); + if (enc) + { + data->release(); + data = enc; + } post_2_write_bulk_thread(data); data->release(); @@ -613,7 +685,7 @@ int async_usb_host::file_move(uint32_t pack_id, const char* from_path, const cha { int base = sizeof(PACK_BASE), datal = strlen(from_path) + 1 + strlen(to_path) + 1; - dyn_mem_ptr data = dyn_mem::memory(base + datal); + dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr; LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); BASE_PACKET_REPLY(*pack, PACK_CMD_FILE_MOVE, pack_id, 0); @@ -621,6 +693,12 @@ int async_usb_host::file_move(uint32_t pack_id, const char* from_path, const cha strcpy(pack->payload, from_path); strcpy(pack->payload + strlen(from_path) + 1, to_path); data->set_len(base + datal); + enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_); + if (enc) + { + data->release(); + data = enc; + } post_2_write_bulk_thread(data); data->release(); @@ -630,13 +708,19 @@ int async_usb_host::file_remove(uint32_t pack_id, const char* file) { int base = sizeof(PACK_BASE), datal = strlen(file) + 1; - dyn_mem_ptr data = dyn_mem::memory(base + datal); + dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr; LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); BASE_PACKET_REPLY(*pack, PACK_CMD_FILE_REMOVE, pack_id, 0); pack->payload_len = datal; strcpy(pack->payload, file); data->set_len(base + datal); + enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_); + if (enc) + { + data->release(); + data = enc; + } post_2_write_bulk_thread(data); data->release(); @@ -647,7 +731,7 @@ int async_usb_host::program_start(uint32_t pack_id, const char* pe_path, const c { int base = sizeof(PACK_BASE), datal = strlen(pe_path) + 1 + strlen(param ? param : "") + 1; - dyn_mem_ptr data = dyn_mem::memory(base + datal); + dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr; LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); if (!param) @@ -657,6 +741,12 @@ int async_usb_host::program_start(uint32_t pack_id, const char* pe_path, const c strcpy(pack->payload, pe_path); strcpy(pack->payload + strlen(param) + 1, param); data->set_len(base + datal); + enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_); + if (enc) + { + data->release(); + data = enc; + } post_2_write_bulk_thread(data); data->release(); @@ -667,13 +757,19 @@ int async_usb_host::program_stop(uint32_t pack_id, uint64_t pid) std::string id(std::to_string(pid)); int base = sizeof(PACK_BASE), datal = id.length() + 1; - dyn_mem_ptr data = dyn_mem::memory(base + datal); + dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr; LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); BASE_PACKET_REPLY(*pack, PACK_CMD_PROCESS_STOP, pack_id, 0); pack->payload_len = datal; strcpy(pack->payload, id.c_str()); data->set_len(base + datal); + enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_); + if (enc) + { + data->release(); + data = enc; + } post_2_write_bulk_thread(data); data->release(); @@ -681,10 +777,8 @@ int async_usb_host::program_stop(uint32_t pack_id, uint64_t pid) } int async_usb_host::program_reboot(uint32_t pack_id) { - dyn_mem_ptr data = dyn_mem::memory(sizeof(PACK_BASE)); - LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); + dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_PROCESS_REBOOT, pack_id, head_enc_type_)); - BASE_PACKET_REPLY(*pack, PACK_CMD_PROCESS_REBOOT, pack_id, 0); post_2_write_bulk_thread(data); data->release(); diff --git a/pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.h b/pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.h index 7a5391e..e0fef72 100644 --- a/pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.h +++ b/pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.h @@ -13,6 +13,7 @@ #include #include #include +#include typedef struct _usb_ep @@ -44,6 +45,10 @@ class async_usb_host : public refer safe_fifo in_que_; safe_fifo out_que_; + uint32_t head_enc_type_; + uint32_t payload_enc_type_; + uint8_t enc_data_; + void thread_read_bulk(void); void thread_write_bulk(void); void thread_pump_task(void); @@ -51,7 +56,7 @@ class async_usb_host : public refer int bulk_write_buf(uint8_t* buf, int* len); // return error code int inner_write_bulk(data_source_ptr data, int* err); void post_2_write_bulk_thread(data_source_ptr data); - dyn_mem_ptr handle_data_in(dyn_mem_ptr data, uint32_t* used, packet_data_base_ptr* more); + dyn_mem_ptr handle_data_in(dyn_mem_ptr& data, uint32_t* used, packet_data_base_ptr* more); public: async_usb_host(std::function cmd_handler = std::function()); @@ -61,16 +66,21 @@ protected: public: static int enum_usb_endpoints(libusb_device* dev, std::vector& eps); - static dyn_mem_ptr base_packet(int cmd, uint32_t id); + static dyn_mem_ptr base_packet(int cmd, uint32_t id, uint32_t encrypt = ENCRYPT_CMD_NONE); public: int start(libusb_device* dev); int stop(void); + uint32_t& encrypt_type_packet_head(void); + uint32_t& encrypt_type_payload(void); + uint8_t& encrypt_data(void); + public: int get_peer_protocol_version(uint8_t* main, uint8_t* sub); int get_peer_status(LPEP0REPLYSTATUS status); int restart_peer_bulk(uint32_t timeout = 1000/*ms*/); + int set_gadget_encrypting_method(uint32_t cmd_enc = ENCRYPT_CMD_NONE, uint32_t payload_enc = ENCRYPT_NONE, uint8_t enc_data = 0); int send_heart_beat(uint32_t pack_id); int get_settings(uint32_t pack_id);