Cloud edge cooperative processing device and processing method for information interaction

Abstract

The invention discloses a cloud edge collaborative information interaction processing device, method and system with an endogenous security architecture. The equipment comprises a main processor, a hardware security chip, a programmable logic unit, a communication unit and an equipment management unit. A trusted execution environment is constructed in the hardware security chip and is in isolated communication with a common execution environment of the main processor through a security bus, a security computing engine, a remote attestation module and a trusted key warehouse are arranged in the trusted execution environment, and the programmable logic unit is directly controlled by the trusted execution environment to realize dynamic hardware acceleration. The communication unit is provided with independent interfaces which are connected with the two execution environments respectively, unification of hardware-level security isolation and efficient cooperative computing is achieved, and the problems of privacy disclosure and untrusted process in cloud edge collaboration are solved.

Description

Technical Field

[0001] This invention belongs to the field of data processing and communication technology, specifically relating to a cloud-edge collaborative processing device and method for information interaction. Background Technology

[0002] With the deep integration of IoT, Industrial Internet, and AI technologies, massive amounts of data are generated at the edge by a vast number of terminal devices. Traditional centralized cloud computing models struggle to meet the demands of applications requiring high real-time performance, reliability, and security due to issues such as network latency, bandwidth constraints, and data privacy concerns. The cloud-edge collaborative computing architecture has emerged to address this need. By deploying devices with computing capabilities close to the data source at the network edge, these devices work collaboratively with the cloud center, aiming to achieve low latency, high bandwidth utilization, and data privacy protection.

[0003] However, existing cloud-edge collaboration solutions still face the following prominent technical shortcomings:

[0004] Existing edge devices mostly employ software-level security measures (such as firewalls and software encryption), making their security boundaries vulnerable to breach. During collaborative processing, sensitive data (such as raw video streams, personal biometric information, and industrial formulas) and core model parameters need to be exchanged between devices or with the cloud, posing a risk of theft, tampering, or malicious analysis. The lack of a hardware-level, verifiable root of trust makes it difficult for participating parties to verify each other's authenticity and integrity.

[0005] Even if the task is successfully unloaded and collaboratively completed, the authenticity of its processing is difficult to trace and audit. Existing technologies lack a lightweight, verifiable mechanism to prove that a certain calculation result was indeed generated collaboratively by a designated device, according to predetermined logic, and in a secure environment. This leads to doubts about the credibility of the collaborative results, making it difficult to apply to fields with strict auditing requirements, such as finance, judiciary, and high-value-added industrial control.

[0006] Privacy-preserving computation technologies introduced to enhance security (such as fully homomorphic encryption and secure multi-party computation) often incur huge computational overhead, severely limiting the real-time processing capabilities of the system. Existing edge device hardware architectures have failed to efficiently integrate strong security isolation capabilities with high-performance parallel computing units, resulting in a dilemma in scenarios requiring both security and speed.

[0007] Existing scheduling systems primarily focus on computational load and network status, rarely considering the real-time security status of edge devices (such as whether they have been intruded upon or their firmware has been tampered with) as a key scheduling criterion. This can lead to sensitive tasks being incorrectly scheduled to execute on compromised devices, causing serious security incidents. Summary of the Invention

[0008] To address the shortcomings of existing technologies, the purpose of this invention is to provide a cloud-edge collaborative processing device and method for information interaction that can build a trusted foundation from the hardware level, achieve efficient collaboration while ensuring data privacy and computational trust, and intelligently schedule based on security status.

[0009] The technical solution adopted by this invention to solve its technical problem is:

[0010] A cloud-edge collaborative information interaction processing device with an inherent security architecture, comprising:

[0011] Hardware security chip, programmable logic unit, main processor, communication unit and device management unit;

[0012] The hardware security chip has a trusted execution environment built in it, and the main processor runs a normal execution environment.

[0013] The trusted execution environment communicates with the normal execution environment via a hardware-isolated security bus;

[0014] The trusted execution environment is configured with: a secure computing engine for performing sensitive data processing and privacy computing tasks under isolation and protection; a remote verification module for proving the integrity of its own code and state to external verifiers; and a trusted key repository;

[0015] The programmable logic unit is directly connected to and driven by the trusted execution environment to implement dynamically reconfigurable hardware acceleration functions defined by the secure computing engine.

[0016] The device management unit is configured to receive a trusted task descriptor from the cloud or an adjacent edge device, verify its signature, and then securely import the privacy computing subtasks defined in the task and their associated hardware acceleration function configuration streams into the trusted execution environment for execution.

[0017] Preferably, the device further includes:

[0018] The environmental perception module is used to collect the device's own operational fingerprint and the channel characteristics of external communication links in real time;

[0019] The proof report generated by the remote proof module incorporates real-time fingerprints and channel features collected by the environment perception module, forming a spatiotemporally bound dynamic trusted proof.

[0020] Preferably, the communication unit includes at least two physically independent communication interfaces:

[0021] The first interface is connected to the normal execution environment and is used to transmit non-sensitive control signaling and public data.

[0022] The second interface is directly connected to and exclusively controlled by the Trusted Execution Environment (TEE), and is dedicated to establishing point-to-point secure communication channels between TEEs of multiple devices.

[0023] Preferably, the programmable logic unit is an FPGA, and the hardware security chip integrates an FPGA configuration controller.

[0024] The secure computing engine generates a signed bitstream file based on the current task requirements, and dynamically reconfigures the FPGA locally through the FPGA configuration controller to form multiple physically isolated hardware acceleration function regions on the FPGA that match the current task.

[0025] Another technical problem to be solved by the present invention is to provide a trusted collaborative reasoning method based on any of the above-mentioned devices, comprising the following steps:

[0026] S1: The first edge device acts as the task initiator. Its trusted execution environment decomposes the inference task into multiple privacy-preserving sub-tasks based on the AI ​​model to be executed, and generates a trusted task descriptor containing computational logic and data requirements for each sub-task.

[0027] S2: The first edge device broadcasts a collaboration request and the trusted task descriptor to one or more second edge devices through its normal execution environment;

[0028] S3: After verifying the signature of the trusted task descriptor, the device management unit of the second edge device imports the privacy-preserving subtasks therein into its own trusted execution environment;

[0029] S4: The trusted execution environments of each edge device establish a secure channel for bidirectional authentication based on remote proof, and based on secure multi-party computation or homomorphic encryption protocols, they collaboratively execute the privacy-preserving sub-tasks without exposing their respective local original data to obtain partial inference results;

[0030] S5: The trusted execution environment of the first edge device aggregates all partial inference results, generates the final inference result and a collaborative computation proof jointly signed by the trusted execution environments of all participating devices, and outputs the proof through the ordinary execution environment.

[0031] Preferably, in step S4, the collaborative execution specifically includes:

[0032] The trusted execution environment of each edge device dynamically compiles the computationally intensive operators that can be processed in parallel in the computing task into hardware acceleration function configuration streams, and distributes them to their respective connected programmable logic units for parallel acceleration processing.

[0033] The processing results of the programmable logic unit are directly transmitted back to the secure computing engine in the trusted execution environment via the secure bus for subsequent encrypted aggregation operations.

[0034] Preferably, the collaborative computation proof described in step S5 includes at least: the hash value of the final inference result, the dynamic trusted proof digest of all participating devices, the hash value of the task descriptor, and the aggregate signature signed by the private keys of the trusted execution environment of each device in a specific order.

[0035] Preferably, in step S3, before the second edge device imports the privacy-preserving subtask, its trusted execution environment first assesses the matching degree between local resources and task requirements.

[0036] If there is a mismatch, the system will send a resource claim containing its dynamic trusted proof to the first edge device or cloud scheduler through its normal execution environment to trigger task reallocation or negotiation of a new collaboration strategy.

[0037] Another technical problem to be solved by the present invention is to provide a cloud-based collaborative scheduling system, comprising:

[0038] A trusted task compiler is used to compile and decompose a user-submitted AI model or data processing flow into a set of trusted task descriptors suitable for execution of the method described in any one of claims 5-8.

[0039] The Device Trust Status Registry is used to record and verify the dynamic trust certificates submitted by each edge device.

[0040] The collaborative path optimizer is used to select the optimal set of participating devices and communication paths for a trusted task descriptor based on task requirements, device trust status, and real-time network topology, and to generate a trusted collaborative orchestration strategy to be distributed to the task initiating device.

[0041] Another technical problem to be solved by the present invention is to provide a computer-readable storage medium having a computer program stored thereon, characterized in that, when the computer program is executed by a processor, it implements the steps of the trusted collaborative reasoning method as described above, or implements the functions of each module in the cloud collaborative scheduling system described above.

[0042] The beneficial effects of this invention are as follows:

[0043] By integrating a hardware security chip with a built-in Trusted Execution Environment (TEE) into each edge device and is hardware isolated from the ordinary execution environment, a hardware-protected "secure enclave" is provided for sensitive data processing and privacy computing. This architecture ensures that even if the ordinary environment is compromised, the core algorithms and sensitive data remain secure within the TEE, laying an immutable hardware root of trust for trusted collaboration. By directly connecting and driving programmable logic units (such as FPGAs) to the TEE, key algorithms in privacy computing tasks defined within the TEE can be dynamically compiled and loaded onto the FPGA, forming hardware-accelerated functions. This achieves "secure environment control, dedicated hardware execution," ensuring that the entire computation process and data remain within a secure isolation domain while achieving near-hardware processing performance and energy efficiency, effectively resolving the conflict between security and performance.

[0044] The trusted collaborative reasoning method and dynamic trusted proof mechanism proposed in this invention enable each participating device to provide spatiotemporally bound proof of its operational status. The final generated "collaborative computation proof" is jointly signed by the TEEs of all participants, forming an independently verifiable and unforgeable "computation credential" that fully records "who, in what state, participated in what task, and produced what result," achieving full-chain trusted traceability and auditing of the collaborative process. The cloud-based collaborative scheduling system uses the device's "dynamic trusted proof" as one of the core scheduling criteria, enabling real-time exclusion of untrusted nodes and prioritizing sensitive tasks for execution in high-trust device clusters. This gives the entire cloud-edge collaborative system adaptive security posture capabilities, significantly improving the system's resilience and reliability in the face of threats.

[0045] The equipment features a resource matching assessment and feedback mechanism, enabling it to perform self-checks before accepting tasks and declare its own status through a trusted channel. This allows the system to dynamically adjust its coordination strategy, avoiding the assignment of tasks to unsuitable equipment, thus improving the success rate of task execution and the overall resource utilization efficiency of the system. Attached Figure Description

[0046] Figure 1 This is a schematic diagram of the principle of the present invention;

[0047] Figure 2 This is a flowchart of the present invention. Detailed Implementation

[0048] The present invention will be further described below with reference to the accompanying drawings and specific embodiments, so that those skilled in the art can better understand and implement the present invention. However, the embodiments are not intended to limit the present invention.

[0049] Example 1

[0050] See Figure 1As shown, this embodiment describes the hardware and software architecture of the edge processing device provided by the present invention. As a key node in the cloud-edge collaborative network, the core of this device lies in its built-in security capabilities at the hardware level.

[0051] The device mainly includes a main processor, a hardware security chip, a programmable logic unit, a communication unit, and a device management unit.

[0052] The main processor, for example, uses a multi-core ARM Cortex-A series processor and runs the main operating system (such as Linux), forming a general execution environment. This general execution environment is responsible for running common network protocol stacks, device management daemons, and non-sensitive business applications.

[0053] Hardware security chips, such as SoC security islands integrating ARM TrustZone technology or standalone Trusted Platform Module (TPM) chips, have a Trusted Execution Environment built inside. The Trusted Execution Environment communicates with the ordinary execution environment through a hardware-isolated security bus (such as a hardware-hardened AXI bus or a dedicated Mailbox), ensuring that data exchange between the two is controllable and auditable.

[0054] Within the Trusted Execution Environment (TEE), several core security modules run: A Secure Computation Engine: This engine loads and executes signed trusted applications delivered from the cloud. These applications encapsulate specific privacy-preserving computation algorithms, such as secure multi-party computation protocol functions, homomorphic encryption operators, or federated learning client logic. All computations involving raw sensitive data (such as facial images, raw waveforms of device vibration, and key production parameters) are performed within this engine. A Remote Proof Module: Based on the unique identifier of the hardware security chip and internally stored proof keys, this module generates a standard-compliant proof report. The report includes metrics (hash values), firmware versions, and other information for all trusted applications within the current TEE, used to prove the integrity and trustworthiness of its software state to external verifiers (such as the cloud or other edge devices). A Trusted Key Repository: This is a secure storage area used to securely generate, store, and use asymmetric key pairs (for remote proof and digital signatures) and symmetric keys (for data encryption). Programmable logic units, such as a field-programmable gate array (FPGA), are used. Their configuration ports are directly connected to the configuration controller within the hardware security chip via a private configuration bus, which is located within the security boundary of the TEE. Therefore, the entire configuration process of the programmable logic unit is completely controlled by the trusted execution environment, ensuring the confidentiality and integrity of the configuration bitstream. The secure computing engine can dynamically compile high-performance operators (such as specific encryption algorithms and matrix multiplication-addition) in computing tasks into a bitstream, and load it onto the programmable logic unit through this controller, forming a hardware accelerator managed by the secure environment. The communication unit includes at least two physically independent network interface controllers. The first network interface connects to the normal execution environment for regular network communication. The second network interface connects directly to the trusted execution environment via a dedicated secure data path. A lightweight secure network protocol stack runs within the trusted execution environment, which can independently control the second network interface to establish point-to-point, end-to-end encrypted direct connection channels with the trusted execution environments of other trusted edge devices. The device management unit runs in the normal execution environment. Its main function is to listen for "trusted task descriptors" (a structured data packet containing task metadata, execution logic hash value, and cloud signature) from the cloud or the task initiating device; verify the descriptor signature using a pre-set root certificate; and after successful verification, securely import the privacy computing subtask pointed to by the descriptor and its associated configuration data into the trusted execution environment via the secure bus for processing by the secure computing engine.

[0055] Example 2

[0056] This embodiment is a further optimization of the first embodiment, aiming to enhance the real-time performance and non-forgeability of device verification.

[0057] This edge processing device also integrates an environment awareness module. This module contains a set of sensors and software drivers for real-time acquisition of two types of information: the device's own operational fingerprint, such as the current CPU core frequency and load rate, memory access pattern characteristics, and instantaneous bus traffic sampling; and external communication link channel characteristics, such as specific dimensions of signal strength index (RSSI) and channel state information (CSI) when communicating with neighboring devices or gateways. When the remote proof module is requested to generate a proof report, it not only collects software state information but also obtains a snapshot of instantaneous environmental characteristic data at a specific timestamp from the environment awareness module and embeds the hash value of this snapshot into the final proof report. This generates a spatiotemporally bound dynamic trusted proof. Any attempt to replay an old proof or simulate software state fails because the physical environment characteristics at a specific moment cannot be replicated, greatly enhancing the proof's liveness and resistance to attacks.

[0058] Example 3

[0059] See Figure 2 As shown, this embodiment describes how multiple aforementioned edge processing devices collaborate to complete a privacy-preserving AI inference task. The task is assumed to be "to collaboratively determine whether a target appears in the monitored area without sharing the original video streams from each camera."

[0060] Step 1: Task Decomposition and Initiation. The first edge device (such as a regional edge server) acting as the coordinator receives the inference task. Its secure computing engine in its trusted execution environment cleverly decomposes the object detection model (such as YOLO) into multiple privacy-preserving subtasks based on a pre-installed model segmentation algorithm. For example, it decomposes it into "feature extraction subtask A" and "region determination subtask B". Subsequently, it generates a trusted task descriptor for each subtask, which includes the subtask's execution logic identifier, a description of the required input data format (not the data itself), and the minimum trust requirements for participating devices.

[0061] Step 2: Broadcasting the collaboration request. The first edge device broadcasts the collaboration request and the corresponding trusted task descriptor to other eligible edge devices (such as smart camera nodes) within the area through its normal execution environment.

[0062] Step 3: Task Verification and Import. Upon receiving the request, the second edge device (smart camera) first verifies the cloud signature of the descriptor using its device management unit. After successful verification, the device management unit imports the descriptor for "Feature Extraction Subtask A" into its trusted execution environment via the secure bus. Before formal execution, the trusted execution environment can quickly assess whether local resources (such as current TEE memory and FPGA free resource blocks) meet the task requirements. If not, it provides a resource declaration through the normal environment.

[0063] Step Four: Secure Collaborative Computation. All participating devices, through their directly connected dedicated network interfaces, mutually authenticate each other's identities and states using remote authentication modules, establishing a secure channel. Subsequently, each camera node, within its local trusted execution environment, performs "Feature Extraction Subtask A" using its own raw video frame data. However, the output is not an image feature map, but rather an encrypted intermediate result processed by homomorphic encryption or secret sharing. These intermediate results are sent to the first edge device via the secure channel. After collecting all encrypted intermediate results, the trusted execution environment of the first edge device securely executes "Region Determination Subtask B" within its TEE, ultimately obtaining the inference result of the encrypted state (such as the probability of "target existence"), and decrypts it to obtain the plaintext result.

[0064] Step 5: Generate and Output a Trusted Proof. After completing the computation, the trusted execution environment of the first edge device generates a collaborative computation proof. This proof includes at least: the hash value of the final inference result, a digest of the dynamic trusted proofs provided by all participating devices during the computation, and the hash value of the task descriptor. It then requests the trusted execution environments of each participating device to sequentially sign the digest of this proof using their private keys, ultimately forming an aggregate signature. This collaborative computation proof with the aggregate signature, along with the inference result, is output to the user or upper-layer application through the normal execution environment. Any third party can verify the authenticity and integrity of this proof using publicly available information.

[0065] In step four above, if the subtask involves a large number of convolution calculations, the trusted execution environment of each device can dynamically compile the convolution operator into a configuration stream and send it to the FPGA directly connected to the local TEE for hardware acceleration, which significantly improves the efficiency of collaborative computing.

[0066] Example 4

[0067] This embodiment describes a cloud system that works in conjunction with the aforementioned edge devices.

[0068] The system mainly comprises three core components: A Trusted Task Compiler: This receives standard AI models or data processing flows submitted by users. Based on a preset privacy-preserving computing paradigm (such as an MPC-friendly network structure), the compiler automatically compiles and decomposes the model into a set of trusted task descriptors that can be executed in the trusted execution environment of edge devices, and signs each descriptor. A Device Trusted State Registry: This is a real-time updated database. Before starting, periodically heartbeating, or joining a collaborative task, all edge devices need to submit their latest dynamic trusted proofs to this registry. The system verifies the validity of these proofs and records each device's real-time trusted state score, resource capability profile, and network location. A Collaborative Path Optimizer: When it receives an inference task request, the optimizer calls the Trusted Task Compiler to obtain the set of task descriptors. Then, it combines real-time information from the Device Trusted State Registry (prioritizing devices with high trustworthiness and resource matching), as well as the global network topology and load conditions, and uses optimization algorithms (such as constraint planning considering latency and trustworthiness) to select an optimal set of participating devices for the task, and plans efficient communication paths between devices, forming a trusted collaborative orchestration strategy, which is then distributed to the task-initiating device.

[0069] The above embodiments of the present invention are not intended to limit the scope of protection of the present invention. The implementation of the present invention is not limited thereto. All other modifications, substitutions or alterations made to the above structure of the present invention based on the above content of the present invention, in accordance with ordinary technical knowledge and common practice in the field, without departing from the basic technical idea of ​​the present invention, shall fall within the scope of protection of the present invention.

Claims

1. A cloud-edge collaborative information interaction processing device with an endogenous security architecture, characterized in that, Comprise: A hardware security chip, a programmable logic unit, a main processor, a communication unit and a device management unit; A trusted execution environment is built in the hardware security chip, and a normal execution environment runs on the main processor; The trusted execution environment and the normal execution environment communicate through a hardware isolated secure bus; The trusted execution environment is configured with: a secure computing engine for executing sensitive data processing and privacy computing tasks under isolated protection; a remote attestation module for proving the integrity of its own code and state to external verification parties; and a trusted key repository; The programmable logic unit is directly connected to the trusted execution environment and is driven by it, and is used to implement a hardware acceleration function defined by the secure computing engine and dynamically reconfigurable; The device management unit is configured to receive a trusted task descriptor from the cloud or an adjacent edge device, verify its signature, and then securely import a privacy computing subtask defined in the task and its associated hardware acceleration function configuration stream into the trusted execution environment for execution. The device further comprises:

2. The apparatus of claim 1, wherein, An environment perception module for collecting the running fingerprint of the device itself and the channel characteristics of the external communication link in real time; The attestation report generated by the remote attestation module integrates the real-time fingerprint and channel characteristics collected by the environment perception module, forming a spatiotemporally bound dynamic trusted attestation. The communication unit includes at least two physically independent communication interfaces:

3. The apparatus of claim 1, wherein, The first interface is connected to the normal execution environment and is used to transmit non-sensitive control signaling and public data; The second interface is directly connected to the trusted execution environment and is exclusively controlled by it, and is used to establish a point-to-point secure communication channel between the trusted execution environments of multiple devices. The programmable logic unit is an FPGA, and an FPGA configuration controller is integrated in the hardware security chip; 4. The apparatus of claim 1, wherein, The secure computing engine generates a signed bitstream file according to the current task requirement, and performs dynamic local reconfiguration on the FPGA through the FPGA configuration controller, so as to form multiple physically isolated hardware acceleration function areas on the FPGA that match the current task. The steps include:

5. A method of trusted co-inference based on the device of any of claims 1-4, characterized in that, S1: The first edge device as a task initiator, its trusted execution environment decomposes an inference task into multiple privacy protection subtasks according to an AI model to be executed, and generates a trusted task descriptor containing the calculation logic and data requirement for each subtask; S2: The first edge device broadcasts a collaboration request and the trusted task descriptor to one or more second edge devices through its normal execution environment; S3: The device management unit of the second edge device verifies the signature of the trusted task descriptor, and then imports the privacy protection subtask therein into its trusted execution environment; S4: The trusted execution environments of the edge devices establish a bidirectional authentication secure channel based on remote attestation, and collaboratively execute the privacy protection subtasks based on secure multi-party computation or homomorphic encryption protocol without exposing their local original data, to obtain partial inference results. ​ S5: The trusted execution environment of the first edge device aggregates all partial inference results to generate a final inference result and a collaborative computing proof jointly signed by the trusted execution environments of all participating devices, and outputs the proof through the normal execution environment.

6. The method of claim 5, wherein, In step S4, the collaborative execution is specifically: The trusted execution environment of each edge device dynamically compiles the computationally intensive operators in the computing task that can be processed in parallel into a hardware acceleration function configuration stream and issues it to the programmable logic unit connected to it for parallel acceleration processing. The processing result of the programmable logic unit is directly returned to the secure computing engine in the trusted execution environment through a secure bus for subsequent encrypted aggregation operation.

7. The method of claim 5, wherein, The collaborative computing proof in step S5 at least includes: the hash value of the final inference result, the dynamic trusted proof digest of all participating devices, the hash value of the task descriptor, and the aggregated signature signed by the private keys of the trusted execution environments of each device in a specific order.

8. The method of claim 5, wherein, In step S3, before importing the privacy protection subtask, the trusted execution environment of the second edge device first evaluates the matching degree of local resources and task requirements. If not matched, it feeds back the resource declaration containing its dynamic trusted proof through its normal execution environment to the first edge device or cloud scheduler to trigger task reassignment or negotiate a new collaborative strategy.

9. A cloud collaborative scheduling system, characterized in that, Comprise: A trusted task compiler for compiling and decomposing the AI model or data processing flow submitted by the user into a set of trusted task descriptors suitable for the method of any one of claims 5-8; A device trusted state registry for recording and verifying the dynamic trusted proof submitted by each edge device; A collaborative path optimizer for selecting the optimal set of participating devices and communication paths for the trusted task descriptor according to the task requirements, device trusted state and real-time network topology, and generating a trusted collaborative orchestration strategy to issue to the task initiator device.

10. A computer-readable storage medium having stored thereon a computer program, characterized in that, The computer program is executed by the processor to realize the steps of the trusted collaborative inference method of any one of claims 5 to 8, or realize the functions of each module in the cloud collaborative scheduling system of claim 9.

Images