Security computing method and device for robot cluster collaboration and medium

Abstract

The embodiment of the invention discloses a safety calculation method and device for robot cluster collaboration and a medium, and relates to the technical field of safety calculation, and the method comprises the steps: carrying out the participant authentication of a robot cluster and a production enterprise node in advance, and carrying out the dynamic identity verification of each robot after the participant authentication is passed, the operation feature data of each target robot passing verification are extracted and encrypted, and encrypted feature vectors are determined; splitting the encrypted feature vector into a plurality of data fragments, storing the data fragments to a distributed node, obtaining a predetermined task cooperation strategy, and distributing the task cooperation strategy to an edge computing node in a secret sharing manner; executing safety calculation in a ciphertext state through a task cooperation strategy and the plurality of data fragments, determining a joint motion control instruction of each target robot, and generating corresponding zero-knowledge proof data; and after the verification is passed, the encrypted control instruction is distributed through the block chain smart contract, so that safety calculation of robot cluster collaboration is realized.

Description

Technical Field

[0001] This specification relates to the field of data security technology, and in particular to a secure computing method, device and medium for robot swarm collaboration. Background Technology

[0002] With the rapid development of industrial automation technology, industrial robot swarms are undertaking increasingly complex collaborative tasks in scenarios such as automobile manufacturing, electronic assembly, and logistics sorting. However, traditional collaborative control methods for industrial robot swarms have significant drawbacks.

[0003] First, regarding data security, robot operation data (such as motion trajectories and operational parameters) faces the risk of leakage during transmission and computation. Existing encryption technologies can only ensure data transmission security, but cannot achieve usability without visibility of the computation process. Furthermore, centralized control architectures lack continuous dynamic verification of device identity, meaning that if the robot is tampered with later, the security risks cannot be detected in a timely manner. Second, regarding collaborative flexibility, traditional control modes based on preset rules or static scheduling algorithms are difficult to respond to dynamic changes in the production environment (such as equipment failures or order changes), resulting in insufficient real-time optimization capabilities for task allocation and path planning. Third, regarding compliance management, industrial data needs to meet multi-regional security standards, but existing technologies lack automated auditing and cross-regional compliance adaptation capabilities.

[0004] While existing solutions have attempted to incorporate federated learning or blockchain technologies, they lack the hardware-level trusted execution environment (TEE) to defend against physical attacks. Key management is also susceptible to side-channel leakage risks, and static authentication mechanisms cannot identify malicious nodes exhibiting persistently abnormal behavior. Therefore, current technologies largely rely on data encryption to ensure the security of transmission during secure computation, which fails to meet the full lifecycle security requirements of robot swarm collaboration. Summary of the Invention

[0005] This specification provides one or more embodiments of a secure computing method, device, and medium for robot swarm collaboration, which addresses the following technical problem: Existing technologies mostly employ data encryption to ensure the security of the transmission process in secure computing, which cannot meet the security requirements throughout the entire lifecycle of robot swarm collaboration.

[0006] One or more embodiments of this specification employ the following technical solutions:

[0007] This specification provides one or more embodiments of a secure computing method for robot swarm collaboration. The method includes: pre-authenticating the robot swarm and production enterprise nodes as participants; after successful participant authentication, real-time collection of motion posture data and environmental point cloud data of each robot terminal; dynamic identity verification of each robot to extract and encrypt the operational feature data of each verified target robot to determine an encrypted feature vector; splitting the encrypted feature vector into multiple data fragments, storing them on distributed nodes, and recording the storage address hash on a blockchain; obtaining a pre-determined task collaboration strategy to secretly share and distribute the task collaboration strategy to edge computing nodes; performing secure computation in encrypted state using the task collaboration strategy and the multiple data fragments to determine the joint motion control commands of each target robot and generate corresponding zero-knowledge proof data; after successful verification of the zero-knowledge proof data, distributing encrypted control commands to the corresponding target robot through a blockchain smart contract to achieve secure computation for robot swarm collaboration.

[0008] This specification provides one or more embodiments of a secure computing device for robot swarm collaboration, comprising:

[0009] At least one processor; and,

[0010] A memory communicatively connected to the at least one processor; wherein,

[0011] The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform the above-described method.

[0012] This specification provides one or more embodiments of a non-volatile computer storage medium storing computer-executable instructions configured to perform the above-described method.

[0013] The above-mentioned technical solutions adopted in the embodiments of this specification can achieve the following beneficial effects: Through the technical solutions of the embodiments of this specification, traditional encryption schemes only ensure the security of data transmission, but the data is still exposed in plaintext during the calculation and storage stages. The embodiments of this specification reconstruct the security boundary through a three-level encrypted architecture of dynamic authentication, fragmented storage, and secure computation. In the dynamic authentication stage, dynamic trusted anchors are formed by extracting and verifying the behavioral features of motion posture and environmental point clouds, ensuring the security of the device itself at the source of data generation, and solving the defect that traditional static authentication cannot detect runtime tampering. In the fragmented storage stage, the encrypted feature vector is fragmented by threshold signature and then distributed for storage. Combined with blockchain address hash notarization, it makes it impossible for a single node physical intrusion to obtain effective information. It requires the simultaneous attack on more than a threshold number of nodes, thus overcoming the single-point leakage risk of centralized storage. In the secure computation stage, a multi-party computation protocol is executed in the TEE secure container. Joint motion commands are directly generated in encrypted state, realizing a computation method that is usable but not visible. By integrating the dynamic features of the device during runtime (motion posture), cryptographic fragmentation (threshold signature), and the hardware trusted environment (TEE), a encrypted protection chain covering the entire life cycle of data generation, storage, and computation is constructed. Furthermore, traditional static scheduling relies on a fixed rule base and cannot respond to dynamic disturbances such as equipment failures and order changes. The reinforcement learning-secure computation fusion framework in this specification achieves real-time adaptation, outputting task allocation matrices and path node sequences in real time through deep reinforcement learning, enabling the strategy to dynamically adapt to changes in the production environment. It combines the dynamic decision-making capabilities of reinforcement learning with the privacy protection capabilities of secure computation, solving the adaptability problem of static strategies in complex scenarios. Additionally, existing technologies rely on centralized auditing, making it difficult to verify the compliance of the computation process. The zero-knowledge proof-blockchain dual-engine architecture in this specification achieves mathematical verifiability. Key steps in secure computation, such as joint instruction generation, are accompanied by zero-knowledge proofs, allowing the verifier to confirm computation compliance without obtaining the original data. Instruction distribution records are stored on-chain through smart contracts, and Merkle tree indexes ensure that historical operations are traceable and tamper-proof, meeting industrial security audit requirements. Zero-knowledge proofs transform physical world security rules (such as motion constraints) into mathematically verifiable relationships, and combined with blockchain to build a distributed trust network, achieving provable security across the entire domain, from devices to data. Finally, centralized architectures have the risk of single points of failure and are difficult to adapt to large-scale deployment needs. The data sharding storage and dynamic allocation mechanism for edge computing nodes in the embodiments of this specification enable the system to tolerate the failure of some nodes and ensure the continuous operation of the production line; the industrial system architecture is reconstructed with lightweight cryptographic techniques (threshold sharding, zero-knowledge proof), which achieves distributed elastic expansion while ensuring security, thus breaking the binary opposition between security and efficiency. Attached Figure Description

[0014] To more clearly illustrate the technical solutions in the embodiments or prior art of this specification, the drawings used in the description of the embodiments or prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. In the drawings:

[0015] Figure 1 A flowchart illustrating a safe computing method for robot swarm collaboration provided in the embodiments of this specification;

[0016] Figure 2 A flowchart illustrating another safe computing method for robot swarm collaboration provided in the embodiments of this specification;

[0017] Figure 3 This is a schematic diagram of a secure computing device for robot swarm collaboration, provided as an embodiment of this specification. Detailed Implementation

[0018] To enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this specification, and not all embodiments. Based on the embodiments of this specification, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this specification.

[0019] This specification provides a secure computing method for robot swarm collaboration. It should be noted that the execution entity in these embodiments can be a server or any device with data processing capabilities. In one embodiment, the execution entity is a secure computing system, which includes a control center, edge computing node servers, an industrial control server, and a blockchain node. The control center server serves as the global decision-making hub, used to execute deep reinforcement learning strategy optimization, manage dynamic identity authentication strategies, call blockchain nodes through smart contracts, and implement full-process auditing. The edge computing node servers are secure computing engines, used to perform multi-party secure computation within a TEE secure container, generate encrypted joint motion commands, dynamically allocate robot collaboration groups, and locally verify zero-knowledge proofs. The industrial control server is the device interaction hub, used to collect robot body data (joint position / load / fault status), execute encrypted control commands, and provide feedback on work results (such as weld quality), and to implement industrial protocol conversion.

[0020] Figure 1This is a flowchart illustrating a safe computing method for robot swarm collaboration provided in an embodiment of this specification, such as... Figure 1 As shown, the main steps include the following:

[0021] Step S101: In advance, the robot cluster and the production enterprise node are authenticated as participants. After the participants are authenticated, the motion posture data and environmental point cloud data of each robot terminal are collected in real time. Dynamic identity verification is performed on each robot to extract the running feature data of each target robot that has passed the verification and encrypt it to determine the encrypted feature vector.

[0022] Pre-authentication of participants in the robot cluster and manufacturing enterprise nodes includes: receiving pre-stored hash values ​​of device digital twin models and security vulnerability scan reports submitted by robot manufacturers; verifying the structural integrity of the device digital twin model based on the device digital twin model of each robot to be connected; comparing the device firmware hash value of the robot to be connected with the pre-stored hash value of the security vulnerability scan report; if they are inconsistent, it is determined to be tampered with and access is rejected; receiving the production plan and security management rule base of the manufacturing enterprise nodes, and verifying the compliance of production data usage using a zero-knowledge proof protocol.

[0023] In industrial robot swarm collaboration scenarios, participant authentication is the first line of defense for ensuring system security. Industrial robots are involved in high-value production processes such as vehicle body welding and precision assembly. If their firmware, motion trajectory, and other data are tampered with or leaked, it could lead to significant risks such as production line paralysis and the theft of process secrets. Traditional centralized authentication only verifies the initial identity of the device and cannot cope with dynamic threats such as malicious firmware tampering (e.g., man-in-the-middle attacks injecting backdoor programs) and unauthorized use of production data (e.g., unauthorized access to process parameters).

[0024] In one embodiment of this specification, the industrial control server first receives the digital twin model file of the robot to be connected, along with the hash value of a pre-stored security vulnerability scan report, submitted by the robot manufacturer through an encrypted channel. The digital twin model is a digital image generated based on the physical robot, containing mechanical structure parameters, dynamic characteristics, and communication protocol configuration. The server parses the model file, verifies whether its topology conforms to robot type standards (such as the joint connection rules for SCARA / Delta models defined in ISO 8373), and verifies whether the model data signature is issued by an authorized CA certificate, thus confirming that the model has not been tampered with. Simultaneously, the server sends a firmware hash extraction command to the robot terminal to be connected. The robot terminal calculates the cryptographic hash value of the current firmware locally (using the SHA3-256 algorithm) and sends it back. The server compares this measured hash value with the baseline hash value in the manufacturer's pre-stored security vulnerability scan report. If the two are inconsistent, it indicates that the firmware has been modified during transmission or storage (e.g., malicious code has been implanted), immediately triggering an alarm and refusing access, while simultaneously writing the anomaly record to the blockchain audit log.

[0025] For manufacturing enterprise nodes, the server receives production plan data (including task type, priority, and process parameters) and a security management rule base (including data access permission policies and privacy protection clauses) submitted through a secure API interface. Based on a zero-knowledge proof protocol, the server verifies the compliance of production data usage, compiling the rule base into an arithmetic circuit. The manufacturing enterprise node, acting as the prover, generates a chain of evidence proving that each data call behavior in its production plan satisfies the rule base constraints (e.g., welding robot trajectory data is only used for path optimization and not shared with third parties). The verifier (server) verifies the validity of the proof without obtaining the original data. After verification, the server generates a timestamped authentication token, which, along with the device's digital certificate, is written into the blockchain smart contract as a permission credential for subsequent data access.

[0026] By addressing the issue that conventional solutions relying on static passwords or digital certificates for one-way authentication cannot detect tampering during device firmware operation, this specification's embodiments integrate digital twin structure verification with dynamic firmware hash comparison. This establishes a digital DNA profile for each robot, allowing for real-time identification of any abnormal parameters (such as malicious rewriting of joint control logic). The security management rule base is transformed into verifiable relationships using zero-knowledge proofs, enabling automated mathematical verification of data compliance. By storing authentication tokens and audit logs on a blockchain, even if some server nodes are compromised, attackers cannot forge historical authentication records. Furthermore, the structured verification of the digital twin model provides a benchmark reference for subsequent dynamic identity authentication, creating a closed loop in the entire security chain.

[0027] Dynamic authentication is performed on each robot, specifically including: analyzing the acceleration fluctuation sequence and joint torque change curve in the motion posture data to determine the current motion behavior fingerprint and current joint load characteristics; comparing the Hamming distance between the current motion behavior fingerprint and the pre-stored fingerprint with a preset allowable deviation threshold, and determining that the dynamic behavior verification is passed when the Hamming distance is not greater than the preset allowable deviation threshold; determining whether the current joint load characteristics belong to the preset load range based on the current joint load characteristics and the preset load range corresponding to each robot, and if so, determining that the dynamic joint load verification is passed; acquiring the real-time environmental point cloud data of each robot, matching the real-time environmental point cloud data with the preset safe area 3D spatial data to determine the real-time pose deviation of each robot; performing dynamic environment verification on each robot based on the real-time pose deviation; and determining that the dynamic authentication of the robot is passed when the dynamic behavior verification, dynamic joint load verification, and dynamic environment verification are all passed.

[0028] In collaborative scenarios involving industrial robot clusters, such as multi-robot cooperation on an automotive welding line, dynamic authentication can mitigate ongoing security threats. The operating environment of industrial robots is complex and highly variable, and traditional static authentication based on initial certificates has fatal flaws. Attackers can hijack authenticated devices and perform malicious actions by tampering with joint control parameters, such as a welding robot suddenly accelerating and colliding with a vehicle body, or inducing out-of-bounds operations by falsifying environmental data, such as a transport robot deviating from its safe track.

[0029] In one embodiment of this specification, the server of the edge computing node acquires the motion attitude data stream of the robot terminal in real time via industrial Ethernet. This motion attitude data includes the acceleration fluctuation sequence of the six-axis inertial measurement unit (IMU) and the torque change curves of the joint servo motors, and simultaneously receives environmental point cloud data generated by LiDAR. First, the motion attitude data is parsed, and the acceleration time-series signal is segmented using a sliding window. The spectral features of each axis's acceleration, such as the dominant frequency amplitude and harmonic components, are extracted. The power spectral density is calculated in conjunction with the joint torque curve. A pre-trained convolutional neural network is used to generate a current motion behavior fingerprint, which can be a 128-dimensional feature vector. Simultaneously, the real-time joint load torque is calculated by integrating the torque curve, and after normalization, the current joint load feature is obtained. It should be noted that the current joint load feature here is a scalar value.

[0030] The current motion behavior fingerprint is compared with a pre-stored fingerprint (robot factory calibration data) to calculate the Hamming distance. The pre-stored fingerprint is stored in a Trusted Execution Environment (TEE). The Hamming distance calculation result is compared with a preset allowable deviation threshold. This preset allowable deviation is dynamically adjusted according to the robot type. For example, the threshold for SCARA robots is lower than that for Delta robots. If the calculation result does not exceed the threshold, the robot's motion pattern is considered to conform to historical patterns, and the verification is successful. Next, the preset load range corresponding to the robot model is queried. For example, the load range for the wrist of a welding robot is 0-50 Nm. It is determined whether the current joint load characteristics fall within this range. If the load is abnormal (e.g., reaching 120% of the upper limit of the range), a joint overload warning is triggered. The real-time environmental point cloud data (including 3D coordinates and reflection intensity information) is registered with the preset safe area 3D spatial data (B-rep boundary representation model). The Iterative Closest Point (ICP) algorithm is used to calculate the pose transformation matrix between the point cloud and the model surface, and the translation vector and rotation Euler angle are extracted as real-time pose deviations. If the deviation value is greater than the safety tolerance, such as the translation deviation exceeding 3 times the positioning accuracy, the robot is determined to have left the safe working area.

[0031] Once all three verifications are successful, the server extracts the robot's operational feature data from the encrypted data pool. This operational feature data may include motion trajectory, work cycle, energy consumption parameters, etc. It is encrypted using the national cryptographic SM4 algorithm combined with the session key derived from the edge node to generate an encrypted feature vector.

[0032] This solution integrates cross-verification of motion behavior fingerprints and joint loads to accurately identify advanced persistent threats. For example, in tests in electronic assembly workshops, attackers attempt to replicate the acceleration patterns of legitimate robots to masquerade, but because they cannot simulate the nonlinear relationship between joint loads and torque curves, such as the instantaneous torque fluctuations when a chip picker picks up a chip, they can be intercepted in real time. Environmental point cloud matching further constructs spatially reliable anchor points, which can block malicious behavior that induces robots to collide with shelves by interfering with UWB positioning signals. In addition, the deviation threshold for behavior verification is dynamically adjusted according to the robot's real-time tasks, such as relaxing the tolerance for acceleration fluctuations when carrying heavy objects. The joint load range is automatically updated as the end-effector is changed, such as recalibrating after switching from a welding torch to a gripper. The adaptive characteristics enable the system to maintain high-precision authentication in automotive mixed-line production scenarios (parallel assembly of multiple models). By performing feature extraction and encryption locally at edge nodes (such as generating CNN fingerprints on an FPGA accelerator card) and uploading the verification result summary rather than the original data to the blockchain, the authentication latency is reduced to within the range required by industrial control. Meanwhile, the structured design of encrypted feature vectors (encryption by trajectory / parameter partition) provides direct input for subsequent threshold sharding storage, avoiding data format conversion overhead.

[0033] Step S102: The encrypted feature vector is split into multiple data fragments, stored in distributed nodes, and the storage address hash is recorded in the blockchain. A pre-determined task collaboration strategy is obtained, and the task collaboration strategy is secretly shared and distributed to edge computing nodes.

[0034] The encrypted feature vector is split into multiple data fragments, specifically including: pre-setting fragment security parameters, wherein the security parameters include a reconstruction threshold and a total number of fragments; generating a total number of fragment values ​​based on the fragment security parameters and the encrypted feature vector; and encrypting each fragment value to determine multiple data fragments.

[0035] In collaborative industrial robot clusters (such as multi-robot collaborative welding in automotive assembly lines), sharded storage can ensure data security throughout its entire lifecycle. The operational characteristic data of industrial robots (such as vehicle body positioning trajectories and welding pressure parameters) contains core process secrets. Traditional centralized storage poses a single point of leakage risk; if an attacker compromises a storage node, they can obtain a complete data copy for reverse engineering.

[0036] In one embodiment of this specification, the control center server dynamically sets the sharding security parameters based on the robot cluster size and data security level. The reconstruction threshold (e.g., k=5) indicates that at least 5 shards are needed to restore the original data; the total number of shards (e.g., n=9) indicates that the data is split into 9 shards, satisfying the Byzantine fault tolerance requirement of n≥2k-1. Parameter values ​​are automatically generated by a pre-set strategy library. For high-security scenarios (e.g., military assembly lines), a strong constraint of k=7 / n=10 is used; for general scenarios (e.g., logistics sorting), a flexible configuration of k=3 / n=5 is used. Encrypted feature vectors are processed based on the Shamir secret sharing algorithm. The ciphertext is treated as a constant term over a finite field, and a k-1 degree polynomial is constructed. n distinct integers are selected as independent variables to calculate the polynomial value, resulting in n sharding values. Each sharding value contains an index number and the corresponding function value; for example, shard 1 is (1, f(1)) and shard 2 is (2, f(2)). This process ensures that any k fragments can be used to recover the ciphertext through Lagrange interpolation; less than k fragments cannot yield any valid information.

[0037] Each shard value is encrypted twice to defend against man-in-the-middle attacks. Attribute-based encryption (ABE) is used, extracting the shard index number as an attribute label (e.g., "shard_region A_robot group 1"). The shard value is encrypted using the edge node's public key to generate a ciphertext shard; a digital signature (ECDSA algorithm) is added to prevent shard tampering. The format of each encrypted data shard is: {ABE ciphertext, index signature, timestamp}.

[0038] The data is sharded into n pieces and distributed to geographically isolated distributed nodes, such as the edge server of factory A, the storage cluster of cloud service provider B, and the private node of manufacturing enterprise C. Storage locations are dynamically selected based on node load status, using a lightweight heartbeat protocol to obtain real-time storage capacity and network latency, prioritizing low-latency, high-availability nodes. A cryptographic hash value (Keccak-256 algorithm) is calculated for each storage address, and the hash value, shard index, and storage node ID are packaged into a transaction and written to the blockchain smart contract. For example, if shard 1 is stored on node 192.168.1.101:8080, its hash value is recorded as 0x8a3d...cbd7. The smart contract automatically generates Merkle tree storage proofs; any shard access requires verification node signature, and operation logs are uploaded to the blockchain in real time.

[0039] Through the above technical solutions, in response to the problem that traditional solutions rely on full-disk encryption or access control lists (ACLs), once the key is leaked or the administrator's privileges are stolen, attackers can obtain complete data, the embodiments of this specification adopt dual protection of threshold sharding and secondary encryption. Even if an attacker intrudes into an edge node, he can only obtain the ciphertext of a single shard (such as the shard value f(3)), and cannot reconstruct valid information without the other k-1 shards; ABE encryption further ensures that the shards can only be decrypted by authorized nodes; elastic disaster recovery is achieved through dynamic distributed storage, and the shard storage node can tolerate the failure of nk nodes. For example, under the configuration of 9 shards / threshold 5, 4 nodes are allowed to fail, and after the nodes recover, the data can be quickly synchronized through blockchain evidence storage; blockchain evidence storage is combined with Merkel proof, and the storage address hash is uploaded to the chain to form an immutable record. Any shard access must submit Merkel path proof to prove its legality; when the robot cluster scale expands (such as adding welding stations), the total number of shards is automatically increased to match security requirements; when edge node resources are tight, the reconstruction threshold is temporarily reduced to alleviate the computational pressure. This adaptive capability significantly reduces operational complexity in mixed-flow production lines (such as car / SUV co-production).

[0040] Obtaining a pre-determined task coordination strategy specifically includes: constructing a Markov decision process model with the objectives of maximizing operational efficiency and minimizing energy consumption; collecting real-time load data, battery power data, and fault status data of each robot in the robot cluster, inputting them into a deep reinforcement learning algorithm, and outputting dynamic task allocation information and path planning information; based on the dynamic task allocation information and path planning information, performing task allocation and path planning on the robot cluster, generating a path node sequence to determine the task coordination strategy.

[0041] In industrial robot swarm collaboration scenarios, such as multi-robot collaborative operations on an automotive assembly line, dynamic task collaboration strategies can achieve high-efficiency self-adaptation. Traditional static scheduling strategies have serious flaws; when there are sudden order changes, equipment failures, or environmental disturbances, the preset task allocation and path planning immediately fail, causing the production line to stop, such as a welding robot malfunction causing the entire line to wait.

[0042] In one embodiment of this specification, the control center server first performs Markov decision process modeling, collecting real-time status datasets of the robot swarm, including load torque data fed back by joint servo motors (representing the current workload), remaining battery power data reported by the battery management system (BMS), and fault status codes from the controller diagnostic interface (such as overheat alarms and communication timeouts). A motion space is defined, i.e., the set of collaborative robot actions, such as the movement coordinate sequence of a welding robot and the grasping and releasing commands of a handling robot. A multi-objective function is constructed with the goals of maximizing work efficiency (number of operations completed per unit time) and minimizing energy consumption (total power integral), and is transformed into a scalar reward value through weighted summation.

[0043] Real-time status data of all robots is acquired periodically via industrial Ethernet (sampling period matches control period); load data is normalized (divided by rated torque), power data is converted to percentage, and fault status is encoded as one-hot vectors. A near-end policy optimization (PPO) algorithm is employed, with the policy network being a hybrid architecture of a 3-layer convolutional neural network (CNN) and a long short-term memory network (LSTM). The input layer receives a status data matrix (rows correspond to robot IDs, columns represent load / power / fault features); the output layer generates a dynamic task allocation matrix (robot-task binding relationship) and a path planning topology graph (nodes represent work positions, edge weights represent movement time). Based on the path planning topology graph, the A* algorithm is used to solve for the optimal path for each robot, discretizing the path into a sequence of key nodes, such as the welding robot path being decomposed into [positioning point → welding point 1 → welding point 2 → reset point].

[0044] The task allocation matrix and path node sequence are encoded into a binary policy file; a threshold parameter is set (e.g., k = 3 / n = 5), and the policy file is split into n fragments using the Shamir algorithm; each fragment is encrypted with the public key of the target edge node (RSA-OAEP scheme); idle edge nodes are selected through a load balancer (based on heartbeat round-trip latency); the encrypted fragments are sent to the target edge node group via a TLS encrypted channel; after local decryption at the edge node, the original policy can be reconstructed only when at least k fragments are collected.

[0045] Through the above technical solutions, leveraging the real-time interaction capabilities of Markov decision processes and deep reinforcement learning, the system successfully achieves second-level dynamic migration of faulty robot tasks in automotive mixed-line production scenarios. By continuously monitoring load and battery status, the system dynamically allocates the dashboard installation task undertaken by the faulty robot to two adjacent idle robots and replans obstacle avoidance paths, ensuring uninterrupted production line operation. A multi-objective reward function is designed: when the battery level is below a threshold, the energy consumption weight is automatically increased, triggering the deep reinforcement learning model to prioritize assigning remote tasks to robots with high battery levels. Secret sharing technology is used to encrypt and distribute policy fragments, ensuring that a single node only holds meaningless fragments. Attackers must simultaneously compromise at least k geographically dispersed edge nodes to reconstruct the policy, significantly increasing attack costs. Policy computation is deployed on industrial-grade servers, and policy reconstruction is performed locally on edge nodes, shortening task allocation response time to within the production line control cycle. Simultaneously, the discretization of path node sequences (e.g., compressing continuous trajectories into key coordinate points) significantly reduces communication overhead and ensures the synchronization accuracy of multi-robot movements.

[0046] Step S103: Through task collaboration strategy and multiple data fragments, perform secure computation in encrypted state to determine the joint motion control commands of each target robot and generate corresponding zero-knowledge proof data.

[0047] Using the task collaboration strategy and the multiple data fragments, secure computation is performed in encrypted state to determine the joint motion control commands for each target robot. Specifically, this includes: parsing the path node sequence in the task collaboration strategy to generate a robot collaboration group; dynamically allocating the robot collaboration group to the target edge node based on the real-time node load information of each edge computing node; and matching multiple associated data fragments associated with the task identifier based on the task identifier to perform multi-party computation within the secure container of the target edge node, outputting the joint motion control commands for each target robot in the robot collaboration group.

[0048] In collaborative scenarios involving industrial robot clusters, such as the synchronous operation of multiple robots on an automotive welding line, encrypted secure computation can achieve dynamic and precise control. Traditional control methods, which use plaintext computation, may expose joint motion commands during the computation process. For example, welding trajectory parameters may be stolen by intermediate nodes, leading to the leakage of core process information. Furthermore, fixed computing nodes cannot cope with sudden load fluctuations, such as an overloaded edge server causing command delays and resulting in asynchronous robot movements.

[0049] In one embodiment of this specification, a secure computing engine deployed on an edge computing node performs the following steps: first, it parses the path node sequence to generate a collaboration group; the server reads the path node sequence from the task collaboration strategy, such as the welding robot path: [Location point P1] → Solder joint W1→ Solder joint W2 → [Reset point H]; Construct a collaborative dependency graph based on spatial location and temporal constraints. If the path nodes of two robots have spatiotemporal intersection, such as when robot A arrives at welding point W1 at time t1, robot B needs to arrive at the adjacent welding point W2 within t1+Δt, then they are assigned to the same collaborative group; The dependency relationship is quantified by directed edge weights, such as a collaborative deviation tolerance of ±50ms; Output a list of collaborative groups, such as group 1 = {robot A, B} which is responsible for welding the left door, and group 2 = {robot C} which operates independently.

[0050] Then, collaboration groups are dynamically allocated to edge nodes. Real-time load data of edge nodes, including CPU utilization, memory usage, and network queue depth, is collected to construct a load scoring model. When CPU utilization exceeds a threshold, it is marked as overloaded. Network latency data is measured using heartbeat round-trip time. Finally, dynamic matching is performed based on the Hungarian algorithm: the computational needs of collaboration groups (such as required floating-point computing power) are modeled as a demand vector; the real-time load scores of edge nodes are converted into a supply vector; the optimal allocation matrix is ​​solved to allocate high-load collaboration groups (e.g., group 1 requires 20 TFLOPs of computing power) to low-load nodes (e.g., node N3 has 25 TFLOPs of idle computing power).

[0051] The data shard storage address associated with the task is retrieved from the blockchain based on the task identifier (e.g., "door welding task ID_202"). Shards are pulled from distributed nodes (e.g., shard 1 comes from factory A edge storage, shard 2 comes from cloud storage B). A TEE secure container based on Intel SGX is created on the target edge node, and the shards are loaded into the container memory, while the shards remain in ABE encryption. Participating nodes verify the integrity of the TEE environment through remote proofs and process the encrypted shards using the SPDZ multi-party computation protocol. The encrypted feature vector shards of the robots within the collaboration group are used as input to calculate the inverse kinematics solution in the encrypted state, such as welding trajectory → joint angle sequence, and output encrypted joint motion control commands (e.g., joint 1 angle + speed command of robot A). After the calculation is completed, a non-interactive zero-knowledge proof (zk-SNARK) is generated in the TEE secure container. The proof includes that the input shards match the policy and that the calculation process conforms to preset rules (e.g., the joint speed does not exceed the safety limit).

[0052] Encapsulated computation is performed throughout the entire process within the TEE secure container. Combined with a multi-party computation protocol, this ensures that even if a single edge node is compromised, the attacker can only obtain encrypted fragments, such as scrambled joint angle values. Zero-knowledge proofs further provide verifiable trust, allowing auditors to verify compliance without obtaining the original instructions, thus eliminating the risk of process parameter leakage. A dynamic load scheduling model optimizes the allocation of collaborative groups in real time on the automotive mixed-flow production line. When the CPU utilization of an edge node exceeds a threshold, its responsible collaborative groups are automatically migrated to idle nodes, ensuring that instruction generation latency remains stable within the control cycle, such as the 100ms welding cycle requirement. Dependency-aware partitioning of collaborative groups fundamentally avoids motion conflicts; two collaborative robots process instructions from the same computing node, guaranteeing trajectory synchronization accuracy.

[0053] Step S104: After the zero-knowledge proof data is verified, encrypted control instructions are distributed to the corresponding target robot through a blockchain smart contract to achieve secure computation for robot cluster collaboration.

[0054] The encrypted control instructions are distributed to the target robot via a blockchain smart contract. Specifically, this includes: obtaining the motion posture data of the target robot and extracting the target hash value of the motion posture data; generating a corresponding symmetric key based on the target hash value using a key derivation function; binding and packaging the encrypted control instructions with the symmetric key, and distributing them to the target robot terminal through a pre-built private communication channel.

[0055] In industrial robot swarm collaboration scenarios, such as the synchronous operation of multiple robots on an automotive assembly line, secure command distribution can prevent the control link from being hijacked. Traditional distribution methods rely on fixed pre-set keys, which are easily compromised through long-term eavesdropping. For example, attackers can obtain welding robot command keys through traffic analysis, and commands transmitted over public communication networks without device-specific characteristics are susceptible to man-in-the-middle tampering. For instance, injecting a false reset command could trigger a collision, making it impossible to trace whether the command distribution process complies with security standards.

[0056] In one embodiment of this specification, the following steps are executed collaboratively by a smart contract and a communication gateway deployed on a blockchain node: First, motion posture data is acquired and a target hash value is extracted. The robot terminal uploads a real-time motion posture data stream (including a six-axis IMU acceleration sequence and joint encoder angle values) via an industrial Ethernet network. The smart contract calls a pre-compiled data processing module to filter out sensor noise, such as using median filtering to process accelerometer glitches. Data from the most recent complete motion cycle is extracted, such as the cycle from welding point positioning to reset for a welding robot. A Keccak-256 hash operation is performed on the cleaned data block to generate a 256-bit target hash value, such as 0x8f3a...c6d1.

[0057] A symmetric key is then derived based on the target hash value. The target hash value is processed using a key derivation function (HKDF-SHA256). In the extraction phase, the target hash value is used as input key material and mixed with a pre-set salt value (such as the robot's serial number) to generate a pseudo-random key. In the expansion phase, the final symmetric key (AES-256 format) is iteratively generated based on the pseudo-random key. A new key is generated each control cycle, and the old key automatically becomes invalid. The key seed (target hash value) changes dynamically with the motion posture to ensure forward security.

[0058] The command-key binding is packaged and distributed via a private channel. Encrypted joint motion control commands, such as "Joint 1: Angle 35.7°, Speed ​​0.2m / s" in SM4 ciphertext, are received from the secure computing module. This command is then encrypted using the generated symmetric key (double encryption), generating a command ciphertext packet. The ciphertext hash of the symmetric key, the command ciphertext packet, the timestamp, and the robot ID are packaged into a transmission unit. A private communication channel based on OPC UA over TSN is established. X.509 certificates are verified bidirectionally between the robot terminal and the communication gateway. After successful verification, an independent virtual link (VLAN ID) is assigned to each robot, and the transmission unit is sent to the target robot terminal via the private channel. The smart contract writes the hash value of the transmission unit to the blockchain (Merck tree index storage). After receiving the transmission unit, the robot terminal locally calculates the hash value of its current motion posture, derives a symmetric key through the same HKDF process, decrypts the command ciphertext packet, and executes joint control.

[0059] Through the above technical solutions, multi-dimensional breakthroughs are achieved through dynamic keys and channel innovation. In terms of attack resistance, traditional static key distribution (such as pre-set PSK) is vulnerable to replay attacks, allowing attackers to intercept historical command packets and resend them infinitely. The technical solution in this specification uses motion posture hash as a dynamic key seed, making the key unique and unpredictable for each control cycle. When the welding robot executes different trajectories, its acceleration fluctuation sequence generates distinctly different hash values, and the derived key is only valid for the current command. Through command-key binding and packaging, the symmetric key is derived from the target robot's unique motion characteristics, making it undecryptable by other robots. For example, if a command packet from handling robot A is maliciously sent to robot B, the derived key decryption fails because B's motion posture hash is inconsistent with A's, and the system automatically triggers an alarm. Through localized key derivation, the robot terminal independently calculates the key based on its own sensor data, without interacting with the central server. Combined with the low jitter characteristics of the TSN network, the command distribution delay is shortened to meet the synchronization requirements of precision assembly, such as the timing tolerance of multiple robots collaboratively tightening vehicle body bolts.

[0060] The method further includes: receiving encrypted feedback information from each target robot, wherein the feedback information includes encrypted joint running status data and task result data, the running status includes position status and velocity status, and the task result data includes completion progress data and quality inspection data; based on the feedback information, optimizing the task coordination strategy through a reinforcement learning algorithm to update the weight parameters of the deep reinforcement learning strategy model and synchronize it to all edge computing nodes.

[0061] In industrial robot swarm collaboration scenarios, preset strategies cannot be dynamically adjusted according to actual working conditions. For example, if a welding robot's trajectory deviates due to workpiece deformation, the system cannot adaptively correct it. In this process, plaintext feedback data is easily stolen, such as vehicle body positioning accuracy parameters being leaked to competitors.

[0062] In one embodiment of this specification, the feedback optimization engine deployed in the control center performs the following steps: First, encrypted feedback information is received. The robot terminal periodically uploads encrypted data packets via industrial Ethernet, including joint operation status data, which includes position status (joint angle values ​​fed back by the encoder, in radians) and speed status (real-time rotational speed of the servo motor, in rad / s). The encrypted data packets also include completion progress data (such as the number of welded joints / total number of welded joints) and quality inspection data (such as the weld width deviation value output by the vision system). A temporary session key is generated locally (based on HKDF and IMU real-time data), and the original data is encrypted with the session key AES-GCM and an Authentication Code (MAC) is attached to prevent tampering.

[0063] The control center uses a pre-stored master key to decrypt the session key. After decrypting the original data, it performs normalization (e.g., mapping angle values ​​to the [-1,1] interval). Next, an incremental training dataset is constructed. The state includes the historical task assignment matrix and feedback joint positions / velocities; the action is the actual sequence of path nodes executed; and the reward is calculated based on quality data, such as higher rewards for smaller weld deviations. The Asynchronous Advantage Actor-Critic (A3C) algorithm is used to update the deep reinforcement learning model. The actor network outputs the probability distribution of new task assignments, the critic network evaluates the state value function, and calculates the policy gradient to update the weight parameters. Backpropagation is used to adjust the weights of the CNN-LSTM hybrid network, and the loss function includes a policy entropy regularization term to prevent overfitting.

[0064] By comparing the Euclidean distance between the weight matrices of the old and new models, a subset of weights whose changes exceed a threshold is extracted. This subset of weights is serialized into a binary stream, encrypted using the target edge node group public key (RSA-3072), and a digital signature (ECDSA) and version number are appended. An encrypted synchronization packet is published via a message queue (such as MQTT). Upon receiving the packet, the edge node verifies the signature and version continuity, decrypts it locally, merges the weights into the deep reinforcement learning model, and returns a confirmation signal to the blockchain for notarization.

[0065] Through the above technical solutions, real-time encrypted feedback data drives online optimization of reinforcement learning, achieving drift compensation, detection of pin alignment deviations by the vision system (encrypted feedback), dynamic adjustment of the mounting paths of adjacent robots by the deep reinforcement learning model, and more accurate exposure of mechanical wear trends through encrypted feedback of joint speed status (such as increased vibration when a joint accelerates), triggering preventative maintenance to avoid sudden failures. Regarding data security, conventional plaintext feedback channels are vulnerable to man-in-the-middle attacks that could steal process parameters. By encrypting feedback data with dynamic keys, the session key for each control cycle is derived from the robot's unique motion characteristics, ensuring that even a single key leak cannot decipher historical data. A differential weight synchronization mechanism is employed, transmitting only significantly changing subsets of weights, enabling model updates for a cluster of thousands of robots to be completed within seconds. Edge nodes independently perform merging operations, avoiding overload on the central server.

[0066] The technical solutions in the embodiments of this specification address the issue that traditional encryption schemes only guarantee data transmission security, but data remains exposed in plaintext during computation and storage. The embodiments in this specification reconstruct the security boundary through a three-tiered encrypted architecture of dynamic authentication, sharded storage, and secure computation. In the dynamic authentication stage, dynamic trusted anchors are formed based on the extraction and verification of behavioral features from motion posture and environmental point clouds, ensuring the security of the device itself at the data source and solving the defect of traditional static authentication in detecting runtime tampering. In the sharded storage stage, encrypted feature vectors are sharded by threshold signatures and then distributed for storage. Combined with blockchain address hashing, this prevents single-node physical intrusions from obtaining effective information, requiring simultaneous attacks on more than a threshold number of nodes, thus overcoming the single-point leakage risk of centralized storage. In the secure computation stage, multi-party computation protocols are executed within a TEE secure container, and joint movement commands are generated directly in encrypted form, achieving a usable but invisible computation method. By integrating the device's runtime dynamic features (motion posture), cryptographic sharding (threshold signature), and the trusted hardware environment (TEE), a secure protection chain covering the entire lifecycle of data generation, storage, and computation is constructed. Furthermore, traditional static scheduling relies on a fixed rule base and cannot respond to dynamic disturbances such as equipment failures and order changes. The reinforcement learning-secure computation fusion framework in this specification achieves real-time adaptation, outputting task allocation matrices and path node sequences in real time through deep reinforcement learning, enabling the strategy to dynamically adapt to changes in the production environment. It combines the dynamic decision-making capabilities of reinforcement learning with the privacy protection capabilities of secure computation, solving the adaptability problem of static strategies in complex scenarios. Additionally, existing technologies rely on centralized auditing, making it difficult to verify the compliance of the computation process. The zero-knowledge proof-blockchain dual-engine architecture in this specification achieves mathematical verifiability. Key steps in secure computation, such as joint instruction generation, are accompanied by zero-knowledge proofs, allowing the verifier to confirm computation compliance without obtaining the original data. Instruction distribution records are stored on-chain through smart contracts, and Merkle tree indexes ensure that historical operations are traceable and tamper-proof, meeting industrial security audit requirements. Zero-knowledge proofs transform physical world security rules (such as motion constraints) into mathematically verifiable relationships, and combined with blockchain to build a distributed trust network, achieving provable security across the entire domain, from devices to data. Finally, centralized architectures have the risk of single points of failure and are difficult to adapt to large-scale deployment needs. The data sharding storage and dynamic allocation mechanism for edge computing nodes in the embodiments of this specification enable the system to tolerate the failure of some nodes and ensure the continuous operation of the production line; the industrial system architecture is reconstructed with lightweight cryptographic techniques (threshold sharding, zero-knowledge proof), which achieves distributed elastic expansion while ensuring security, thus breaking the binary opposition between security and efficiency.

[0067] Figure 2 A flowchart illustrating another safe computing method for robot swarm collaboration provided in the embodiments of this specification is shown below. Figure 2As shown, the participating entities include robot manufacturers, production enterprises, control centers, and edge control nodes. Each entity assumes different responsibilities in the collaborative control process: robot manufacturers are responsible for equipment security protection, providing digital twin models, and adapting communication protocols; production enterprises are responsible for production task planning, data collection, and the release of collaborative control tasks; the control center implements collaborative control strategy management and compliance supervision through smart contracts; and edge control nodes consist of edge computing devices that have passed industrial information security certification and are responsible for executing multi-party secure computation and reinforcement learning strategy optimization.

[0068] In one embodiment of this specification, the process is mainly divided into six steps: participant authentication, data preprocessing, sharded storage, strategy optimization, secure computation and control, and collaborative feedback and optimization. Through four modules—zero-trust authentication, data encryption, intelligent optimization, and smart contracts—the entire process of collaborative control of industrial robot clusters is achieved.

[0069] The first step is participant authentication. Robot manufacturers submit digital twin models of their devices and hash values ​​of security vulnerability scan reports through a zero-trust authentication system, which verifies device security. Manufacturing companies submit production plans and safety management systems, and the compliance of data usage is verified through zero-knowledge proofs. When a robot terminal connects, continuous identity verification is performed based on biological behavioral characteristics (such as motion posture patterns) and environmental perception information (such as sensor data characteristics). Permission information is updated in real time and recorded on the blockchain in the form of smart contracts. The control center monitors the authentication process in real time through smart contracts.

[0070] The second step is data preprocessing. The manufacturing company and its robotic terminals employ a federated learning framework to extract data features and train models locally on each terminal, avoiding the centralized transmission of raw data. Sensitive data such as robot motion trajectories and operational parameters are encrypted using fully homomorphic encryption technology, enabling various operations in encrypted form. The manufacturing company provides collaborative control task parameters (such as task priority and operational accuracy requirements), and the control center uses smart contracts to monitor whether the data preprocessing process complies with industrial information security requirements.

[0071] The third step is sharded storage. A threshold signature mechanism is used to split the encrypted data into multiple shards, each stored on a different distributed storage node. The storage address hash value is recorded on the blockchain, edge control nodes obtain the shard storage location through the blockchain, and the control center records audit logs of the storage process.

[0072] The fourth step is strategy optimization. Based on task requirements, the robot's real-time status (such as load, energy consumption, and fault status), and environmental information (such as obstacle distribution in the workspace), the system dynamically generates task allocation and path planning strategies using deep reinforcement learning algorithms. A Markov decision process model for collaborative robot swarm operations is established, aiming to maximize work efficiency and minimize energy consumption, and the strategy is optimized through continuous trial and error and reward feedback.

[0073] The fifth step is secure computation and control. The manufacturing company issues collaborative control tasks on the blockchain, and the robot terminal sends necessary information to selected edge control nodes via secret sharing technology. The edge control nodes execute reinforcement learning strategy computations using a secure multi-party computation protocol. Upon completion of each key computation step, a zero-knowledge proof is generated to verify computation compliance, and the control center verifies the validity of the proof in real time. The computation results are encrypted and used as control commands, securely distributed to the robot terminal via a blockchain smart contract.

[0074] Step 6: Collaborative Feedback and Optimization. During task execution, the robot terminal transmits encrypted feedback of its operating status (such as position, speed, and fault alarms) and work results (such as completion progress and quality inspection data) to the control center in real time. Based on the feedback information, the control center optimizes the collaborative strategy in real time using reinforcement learning algorithms to form a closed-loop control. Simultaneously, a blockchain smart contract allocates task execution rewards according to the robot's contribution. The allocation record includes metadata such as timestamps and hash values. Manufacturing enterprises can verify data integrity through the result hash, and the robot terminal can query task execution records.

[0075] By innovatively integrating multi-party secure computation, reinforcement learning, and blockchain technology into the collaborative control of industrial robot clusters, multiple breakthroughs have been achieved in data security, collaborative efficiency, and intelligent optimization: First, zero-trust authentication and dynamic key management, combined with fully homomorphic encryption and threshold signature technology, ensure the security of robot operation data throughout the entire process and reduce the risk of data leakage; Second, a reinforcement learning mechanism is introduced to achieve dynamic optimization of robot task allocation and path planning, which improves operational efficiency and reduces energy consumption compared to traditional static scheduling algorithms, effectively adapting to complex and ever-changing industrial production scenarios; Third, smart contracts automatically execute collaborative control strategy management and revenue distribution, reducing enterprise production management costs; Finally, the transformation of industrial robot clusters from "pre-set collaboration" to "intelligent adaptive collaboration" is realized.

[0076] This specification also provides an embodiment of a secure computing device for robot swarm collaboration, such as... Figure 3 As shown, the device includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the above-described method.

[0077] This specification also provides a non-volatile computer storage medium storing computer-executable instructions configured to perform the above-described method.

[0078] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the embodiments of apparatus, devices, and non-volatile computer storage media are basically similar to the method embodiments, so the descriptions are relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0079] The foregoing has described specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in a different order than that shown in the embodiments and may still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily require the specific or sequential order shown to achieve the desired result. In some embodiments, multitasking and parallel processing are possible or may be advantageous.

[0080] The devices, media, and methods provided in the embodiments of this specification are one-to-one correspondences. Therefore, the devices and media also have similar beneficial technical effects as their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.

[0081] The above description is merely one or more embodiments of this specification and is not intended to limit this specification. Various modifications and variations can be made to the one or more embodiments of this specification by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principle of one or more embodiments of this specification should be included within the scope of the claims of this specification.

Claims

1. A secure computing method for robot swarm collaboration, characterized in that, The method includes: The robot cluster and production enterprise nodes are pre-authenticated as participants. After the participants are authenticated, the motion posture data and environmental point cloud data of each robot terminal are collected in real time. Dynamic identity verification is performed on each robot to extract the operation feature data of each target robot that has passed the verification and encrypt it to determine the encrypted feature vector. The encrypted feature vector is split into multiple data fragments, stored in distributed nodes, and the storage address hash is recorded in the blockchain. A predetermined task collaboration strategy is obtained, and the task collaboration strategy is secretly shared and distributed to edge computing nodes. Through the task collaboration strategy and the multiple data fragments, secure computation is performed in encrypted state to determine the joint motion control commands for each target robot and generate corresponding zero-knowledge proof data. After the zero-knowledge proof data is verified, encrypted control instructions are distributed to the corresponding target robot through a blockchain smart contract to achieve secure computation for robot cluster collaboration.

2. The secure computing method for robot swarm collaboration according to claim 1, characterized in that, Pre-qualification of participants in the robot cluster and production enterprise nodes includes: Receive the pre-stored hash values ​​of the device digital twin model and security vulnerability scan report submitted by the robot manufacturer, and verify the structural integrity of the device digital twin model based on the device digital twin model of each robot to be connected; The device firmware hash value of the robot to be connected is compared with the pre-stored hash value in the security vulnerability scan report. If they do not match, it is determined to be tampered with and access is rejected. It receives the production plans and safety management rule base of the production enterprise nodes and uses a zero-knowledge proof protocol to verify the compliance of production data usage.

3. The secure computing method for robot swarm collaboration according to claim 1, characterized in that, Dynamic authentication is performed on each robot, specifically including: The acceleration fluctuation sequence and joint torque change curve in the motion posture data are analyzed to determine the current motion behavior fingerprint and current joint load characteristics. The Hamming distance between the current motion behavior fingerprint and the pre-stored fingerprint is compared with a preset allowable deviation threshold. When the Hamming distance is not greater than the preset allowable deviation threshold, the dynamic behavior verification is deemed successful. Based on the current joint load characteristics and the preset load range corresponding to each robot, determine whether the current joint load characteristics belong to the preset load range. If so, determine that the dynamic joint load verification is passed. The real-time environmental point cloud data of each robot is acquired, and the real-time environmental point cloud data is matched with the three-dimensional spatial data of the preset safe area to determine the real-time pose deviation of each robot. Based on the real-time pose deviation, dynamic environment verification is performed on each robot; When the dynamic behavior verification, dynamic joint load verification, and dynamic environment verification all pass, the robot's dynamic identity verification is deemed successful.

4. A secure computing method for robot swarm collaboration according to claim 1, characterized in that, The encrypted feature vector is split into multiple data fragments, specifically including: Pre-set sharding security parameters, wherein the security parameters include a reconstruction threshold and a total number of shards; Based on the fragmentation security parameters and the encryption feature vector, generate the total number of fragment values; Each shard value is encrypted to identify multiple data shards.

5. A secure computing method for robot swarm collaboration according to claim 1, characterized in that, Obtain a pre-determined task coordination strategy, specifically including: Construct a Markov decision process model with the objectives of maximizing operational efficiency and minimizing energy consumption; The system collects real-time load data, battery power data, and fault status data of each robot in the robot cluster, inputs them into a deep reinforcement learning algorithm, and outputs dynamic task allocation information and path planning information. Based on the dynamic task allocation information and path planning information, the robot cluster is assigned tasks and its path is planned to generate a path node sequence in order to determine the task coordination strategy.

6. A secure computing method for robot swarm collaboration according to claim 1, characterized in that, Through the aforementioned task collaboration strategy and the multiple data fragments, secure computation is performed in encrypted state to determine the joint motion control commands for each target robot, specifically including: Parse the path node sequence in the task coordination strategy to generate a robot collaboration group; Based on the real-time node load information of each edge computing node, the robot collaboration group is dynamically allocated to the target edge node; Based on the task identifier corresponding to the task collaboration strategy, multiple associated data fragments associated with the task identifier are matched to perform multi-party computation within the safe container of the target edge node, and output joint motion control commands corresponding to each target robot in the robot collaboration group.

7. A secure computing method for robot swarm collaboration according to claim 1, characterized in that, The encrypted control commands are distributed to the corresponding target robot via a blockchain smart contract, specifically including: Acquire the motion posture data of the target robot, and extract the target hash value of the motion posture data; A corresponding symmetric key is generated based on the target hash value using a key derivation function. The encrypted control commands are bound and packaged with the symmetric key, and distributed to the target robot terminal through a pre-built private communication channel.

8. A secure computing method for robot swarm collaboration according to claim 1, characterized in that, The method further includes: Receive encrypted feedback information from each of the target robots, wherein the feedback information includes encrypted joint operation status data and operation result data, the operation status includes position status and speed status, and the operation result data includes completion progress data and quality inspection data; Based on the feedback information, the task collaboration strategy is optimized using a reinforcement learning algorithm to update the weight parameters of the deep reinforcement learning strategy model and synchronize them to all edge computing nodes.

9. A secure computing device for robot swarm collaboration, characterized in that, The device includes: At least one processor; and, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the method as described in any one of claims 1-8.

10. A non-volatile computer storage medium storing computer-executable instructions, characterized in that, The computer-executable instructions are configured to perform the method as described in any one of claims 1-8.

Images