Blockchain-based fair incentive method for delay tolerant network

Abstract

This invention belongs to the field of latency-tolerant network technology and discloses a fair incentive method for latency-tolerant networks based on blockchain. The method includes a message sending phase, a message relay phase, a first phase of encrypted data reception, a second phase of encrypted data reception, and a closing phase. It assumes that all nodes in the latency channel network are within the same digital currency system network and can communicate with it. The entity that needs to send a message is the sending node, the entity responsible for relaying messages is the intermediate node, and the entity corresponding to the message is the receiving node. There is no stable communication channel between the sending node and the receiving node. The intermediate node regularly travels between the areas where the sending node and the receiving node are located. When it reaches the area of ​​a certain node, the intermediate node can establish a valid connection with the nodes in that area to achieve communication. This invention has high practical value and efficiency.

Description

Technical Field

[0001] This invention belongs to the field of latency-tolerant network technology, and particularly relates to a fair incentive method for latency-tolerant networks based on blockchain. Background Technology

[0002] Latency-tolerant networks are high-latency, fragmented, and unstable communication networks, often found in remote areas, post-disaster environments lacking basic communication infrastructure, and complex scenarios such as satellite or underwater communication. In these networks, there is typically no reliable communication channel or stable network between message senders and receivers; they rely on intermediary nodes to complete communication. Due to profit-seeking, nodes in latency-tolerant networks tend to enjoy the network's message sending service rather than proactively assuming message forwarding responsibility, leading to the entire network's malfunction. To address this issue, scholars have proposed incentive schemes for latency-tolerant networks based on trusted third parties. These schemes incentivize nodes to forward messages by having the trusted third party send transaction fees to the intermediary nodes. However, in reality, trusted third-party nodes are often nonexistent, and even when they exist, they face centralization problems. Fortunately, blockchain technology, as an effective solution to traditional centralization issues, has gradually developed and matured, leading to the proposal of several latency-tolerant network incentive schemes that utilize blockchain technology to replace trusted third parties. However, existing latency-tolerant network incentive schemes based on blockchain technology place greater emphasis on the interests of the message sender. That is, the relevant credentials or rewards are only sent to the intermediate node after the receiver receives the message. The interests of the intermediate node depend entirely on the message status of the receiver. Such schemes cannot guarantee the interests of the intermediate node.

[0003] If the corresponding benefits of performing message passing cannot be guaranteed, according to game theory analysis, nodes in latency-tolerant networks will no longer actively assume the role of message passing, which will greatly affect the efficiency of the solution in application. Summary of the Invention

[0004] The purpose of this invention is to provide a blockchain-based method for fair incentives in latency-tolerant networks, in order to solve the aforementioned technical problems.

[0005] To address the aforementioned technical problems, the specific technical solution of the blockchain-based latency-tolerant network fair incentive method of the present invention is as follows:

[0006] A blockchain-based method for fair incentives in latency-tolerant networks includes a message sending phase, a message relay phase, a first phase of encrypted data reception, a second phase of encrypted data reception, and a closing phase. The steps for each phase are as follows:

[0007] The message sending phase is as follows: The sending node first sends the message to the intermediate node, which encrypts the message and generates a corresponding encrypted zero-knowledge proof. Then, the intermediate node returns the ciphertext and the zero-knowledge proof to the sending node. After successfully verifying the ciphertext based on the proof, the sending node deploys a smart contract and pre-stores the transaction fee. Simultaneously, it signs the ciphertext data and stores the corresponding signature and other information in the smart contract.

[0008] The message relay stage: After receiving the relevant message, the intermediate node first verifies the message based on the signature, encrypted data and the public key of the sending node. If the verification is successful, the message is stored and sent to the area where the receiving node is located. At the same time, the intermediate node sends a deposit to the smart contract.

[0009] In the first stage of receiving encrypted data: after the intermediate node arrives at the area where the receiving node is located, it forwards the stored encrypted and signature data to the receiving node through a temporary communication channel established with the receiving node. The receiving node also verifies the encrypted data; if the verification is successful, it calls the smart contract function to exchange the decryption key.

[0010] The second stage of receiving encrypted data: The intermediate node learns about the data sent by the receiving node through the blockchain synchronization mechanism, calls the smart contract function to submit the final key exchange information, and the smart contract will verify whether the submitted information is valid. If it is valid, it will automatically send the transaction fee to the intermediate node.

[0011] The closing phase: If the receiving node can decrypt the encrypted data and obtain the original text by submitting information through the intermediate node, the message sending officially ends, and the intermediate node redeems the deposit; if the intermediate node fails to execute the actions specified in the second phase of receiving encrypted data before the deadline, the receiving node can obtain the deposit submitted by the intermediate node as compensation by using only the function in the smart contract.

[0012] Furthermore, the sending node possesses a signature public-private key pair (sk s , pk s The intermediate node possesses a public-private key (y, x), the sending node's signature public-private key is used for signature generation and verification, and the intermediate node possesses an encryption / decryption public-private key, which satisfy the relationship y = g. x .

[0013] Furthermore, the message sending phase includes the following specific steps:

[0014] Assume the message to be sent is m and When a sender needs to send message m to a receiver, it first sends m to an intermediate node. After receiving m, the intermediate node performs the following steps:

[0015] A1: From Select a random number r from the group;

[0016] A2: Calculate the ciphertext c1 = g r and

[0017] A3: Use zero-knowledge proof techniques to generate a proof for the ciphertext (c1, c2);

[0018] A4: Send the proof along with the ciphertext (c1, c2) to the sender;

[0019] After receiving the proof and ciphertext (c1, c2), the recipient performs the following operations:

[0020] B1: Verify the ciphertext (c1, c2) based on the proof and message m;

[0021] B2: Verification successful. Calculate the corresponding hash value c of the ciphertext (c1, c2) using the SHA256 hash function. h = sha256(c1||c2);

[0022] B3: Using the signing private key sk s For hash value c h Signature to obtain δc c At the same time, δc c Send to intermediate node;

[0023] B4: Finally, the smart contract's Send function is called to record this message transmission;

[0024] After transmitting the corresponding data to the intermediate node, the sending node deploys a smart contract to the blockchain system and calls the Send function. The Send function can only be called by the sending node and is used to build and deploy the contract required for the message and prepay the transaction fee for sending the message.

[0025] Furthermore, the message relay stage includes the following specific steps:

[0026] The intermediate node receives the ciphertext (c1, c2), random number r, message m, and corresponding signature δ sent by the sending node. c Then, perform the following operations:

[0027] C1: Calculate the hash value c corresponding to the ciphertext (c1, c2) using the SHA256 hash function. h = sha256(c1||c2)

[0028] C2: Through signature data δ c pk with the sending node's signature public key s For hash value c h Verification is required;

[0029] C3: After the signature verification is valid, use the equation c1 = g r and Verify whether the ciphertext is correctly encrypted;

[0030] If the verification is successful, the intermediate node will store the message and proceed to the receiving node's area. Finally, it will call the smart contract's Forward function to store the deposit. Otherwise, it will do nothing. The Forward function can only be called by intermediate nodes to prevent them from submitting a portion of the deposit if they launch a malicious attack.

[0031] Furthermore, the encrypted data receiving stage one includes the following specific steps:

[0032] Upon reaching the area where the receiving node is located, the intermediate node will send the ciphertext (c1, c2) and the corresponding signature δ of the sending node. c The message is sent to the receiving node. After receiving the message from the intermediate node, the receiving node performs the following operations:

[0033] D1: Calculate the hash value c corresponding to the ciphertext (c1, c2) using the SHA256 hash function. h ′=sha256(c1||c2);

[0034] D2: Through signature data δ c pk with the sending node's signature public key s For hash value c h Verify to confirm that the message actually originated from the sending node;

[0035] D3: If verification is successful, then in Randomly select x′ from the middle;

[0036] D4: Calculation and Subsequently, the receiving node calls the smart contract function Recive_1. This function, called by the receiving node, is used to exchange decryption keys via a peer-to-peer smart contract. Perform a validity check on R.

[0037] Furthermore, the second stage of receiving encrypted data includes the following specific steps:

[0038] Once the intermediate node learns through the blockchain system's consensus mechanism that the receiving node has successfully received and sent the data and triggered the smart contract Recive_1 function, it then performs the following operations:

[0039] E1: The intermediate node obtains R submitted by the receiving node from the smart contract and simultaneously calculates the temporary decryption key A = R. x ;

[0040] E2: Finally, the intermediate node calls the Receive_2 function in the smart contract. The Receive_2 function is used to exchange decryption keys, and the smart contract uses equations... The validity of A is checked. Once the check passes, the smart contract will automatically send the corresponding transaction fee to the intermediate node, thereby protecting the interests of the intermediate node and promoting the development and operation of the latency-tolerant network.

[0041] Furthermore, the closing phase includes the following specific steps:

[0042] After discovering the temporary decryption key A submitted by the intermediate node through the blockchain synchronization mechanism, the receiving node performs the following operations:

[0043] F1: The receiving node retrieves the temporary decryption key A from the smart contract, and then calculates...

[0044] F2: Then, use k to decrypt the ciphertext (c1, c2) to obtain the message m. The calculation steps are as follows:

[0045]

[0046] If the intermediate node fails to send the temporary decryption key A to the smart contract within the specified time, the receiving node can call the smart contract's Close function to punish the intermediate node.

[0047] If the intermediate node fails to provide the receiving node with a temporary decryption key within the specified time, the receiving node calls the Close function to request compensation. The smart contract sends the deposit stored by the intermediate node to the sending node as compensation, and the intermediate node retrieves the deposit through the Close function.

[0048] The blockchain-based latency-tolerant network fair incentive method of this invention has the following advantages: This invention introduces blockchain technology into the solution, thereby avoiding centralization problems, and can also use the inherent properties of blockchain to punish malicious nodes. It can be implemented on any digital currency system with a Turing-complete scripting language, without the need to design a new blockchain, thus exhibiting excellent compatibility and adaptability. Utilizing the automatic script execution feature of the blockchain system, it fully guarantees the fairness between the interests of intermediate nodes and data forwarding. This invention incentivizes intermediate nodes to perform message transmission by setting a reward mechanism, while ensuring the deserved benefits of intermediate nodes in the message transmission process, resulting in higher practical value and efficiency. Attached Figure Description

[0049] Figure 1 This is a schematic diagram of the blockchain-based latency-tolerant network fair incentive system model of the present invention;

[0050] Figure 2 This is a pseudocode diagram of the Send function of the present invention;

[0051] Figure 3 This is a pseudocode diagram of the Forward function of the present invention;

[0052] Figure 4 This is a pseudocode diagram of the Recive_1 function of the present invention;

[0053] Figure 5 This is a pseudocode diagram of the Receive_2 function of the present invention;

[0054] Figure 6 This is a pseudocode diagram of the Close function of the present invention. Detailed Implementation

[0055] To better understand the purpose, structure, and function of this invention, the following detailed description of a blockchain-based delay-tolerant network fair incentive method is provided in conjunction with the accompanying drawings.

[0056] To facilitate understanding of the technical solution of this invention, several basic concepts are first introduced:

[0057] 1. Delay-tolerant networks

[0058] Delay-tolerant networks are channel networks characterized by unstable connections, high latency, and a lack of stable channels between nodes. They typically exist in complex environments such as remote areas where inter-node connections are difficult, or in space or underwater communication environments. In most cases, two nodes in a delay-tolerant network cannot communicate directly for various reasons, such as limited communication range or complex communication environments, and need to rely on other nodes to achieve communication. Specifically, when two connection-limited nodes attempt to communicate, the sender first needs to send a message to an intermediate node traveling between the sender's and receiver's locations. After receiving the message in the sender's location, the intermediate node stores the message locally and sends it to the receiver's location. Upon reaching the destination, the intermediate node forwards the message to the receiver, thus achieving indirect communication between the sender and receiver.

[0059] 2. Blockchain technology

[0060] In 2008, a person using the pseudonym Satoshi Nakamoto proposed a new type of digital currency system—Bitcoin, with blockchain technology serving as its underlying support. Blockchain technology, by combining modules such as P2P networks, hash algorithms, and digital signature algorithms, is considered one of the effective means to solve the problem of centralization in traditional industries. Today, digital currency is the most widespread application scenario for blockchain technology. According to statistics from the digital currency website CoinMarketCap, as of November 19, 2022, 21,790 digital currencies had been proposed. Furthermore, thanks to the emergence and widespread development of smart contracts, most current digital currency systems use smart contracts as their underlying scripting language, thus possessing Turing completeness.

[0061] 3. Bilinear mapping

[0062] To protect the interests of intermediate nodes in the proposed scheme, this invention transforms the exchange of transaction fees due to intermediate nodes and message forwarding services into an exchange of decryption keys and message ciphertext. Based on the identity-based encryption scheme proposed by Boneh and Franklin, this invention proposes a key transmission scheme that utilizes a bilinear mapping to complete the key exchange between the two parties. The basic description of the bilinear mapping is as follows:

[0063] Bilinear mapping It refers to from arrive The mapping, where and For both groups to have an order of a large prime number q, they must also satisfy the following condition:

[0064] ● Non-degradability There exists at least one pair Make

[0065] ● Bilinearity For all all There always

[0066] ● Computability For all Existing polynomial-time algorithm computation

[0067] 4. Digital signature algorithms and properties

[0068] Basic components

[0069] In the method proposed in this invention, the message recipient needs to confirm the validity and integrity of the encrypted message data. Therefore, this invention introduces a digital signature algorithm to fulfill this requirement. A digital signature algorithm typically consists of three parts: a public-private key pair generation algorithm (KeyGen), a signature generation algorithm (Sign), and a signature verification algorithm (Verify).

[0070] ● Public-private key pair generation algorithm (KeyGen)

[0071] Input security parameters and output public / private key pair (ok, sk).

[0072] ● Signature generation algorithm (Sign)

[0073] Input the private key sk and the message m, and output the digital signature data σ.

[0074] ● Signature verification algorithm (Verify)

[0075] Input public key pk, message m and digital signature data σ. If the data signature σ matches the public key pk and message m, the signature verification algorithm outputs 1; otherwise, it outputs 0.

[0076] Digital signature algorithms have the following basic properties:

[0077] ●PK is public, SK is confidential;

[0078] ● SK cannot be calculated from PK, but PK can be calculated from SK;

[0079] ● Only the holder of sk can sign message m.

[0080] Commonly used digital signature algorithms include: Schnorr signature algorithm, ECDSA signature algorithm, and SM2 signature algorithm.

[0081] 5. Zero-knowledge proof

[0082] Zero-knowledge proofs are used by the prover to demonstrate to the verifier that they possess certain secrets without revealing any information about those secrets during the proof process. The typical process for constructing a zero-knowledge proof is as follows:

[0083] · Circuit building The prover builds a circuit corresponding to their own secret at this stage;

[0084] ● Trusted Configuration The prover is responsible for creating the parameters needed to generate and verify the proof at this stage.

[0085] ● Computational Witness The prover calculates all circuit signals that match all circuit constraints in this step;

[0086] ● Create proofThe prover generates the actual proof through a circuit at this stage;

[0087] ● Verification and proof The verifier, through verifying the proof, determines whether the prover knows a certain secret.

[0088] The present invention provides a blockchain-based latency-tolerant network fair incentive method, which mainly includes a message sending phase, a message relay phase, a first phase of encrypted data reception, a second phase of encrypted data reception, and a closing phase. It is assumed that all nodes in the latency channel network are within the same digital currency system network and are capable of communicating with this system network. For ease of understanding, it is assumed that the entity that needs to send a message is the sending node, the entity responsible for relaying messages is the intermediate node, and the entity corresponding to the message is the receiving node. There is no stable communication channel between the sending node and the receiving node. The intermediate node regularly travels between the areas where the sending node and the receiving node are located. When it reaches the area where a certain node is located, the intermediate node can establish a valid connection with the nodes in that area to achieve communication.

[0089] like Figure 1 As shown, the blockchain-based latency-tolerant network fair incentive method of the present invention includes the following steps: message sending phase, message relay phase, encrypted data receiving phase one, encrypted data receiving phase two, and closing phase:

[0090] Message sending phase: The sending node first sends the message to the intermediate node, which encrypts the message and generates a corresponding encrypted zero-knowledge proof. The intermediate node then returns the ciphertext and zero-knowledge proof to the sending node. After successfully verifying the ciphertext based on the proof, the sending node deploys the smart contract, pre-stores the transaction fee, signs the ciphertext data, and stores the corresponding signature and other information in the smart contract.

[0091] Message relay stage: After receiving the relevant message, the intermediate node first verifies the message based on the signature, encrypted data and the public key of the sending node. If the verification is successful, the message is stored and sent to the region where the receiving node is located. At the same time, the intermediate node sends a deposit to the smart contract.

[0092] Phase 1 of Ciphertext Data Reception: After the intermediate node arrives at the receiving node's location, it forwards the stored ciphertext and signature data to the receiving node through a temporary communication channel established with the receiving node. The receiving node also verifies the ciphertext data; if verification is successful, it calls the smart contract function to exchange the decryption key.

[0093] Phase Two of Cipher Data Reception: The intermediate node learns about the data sent by the receiving node through the blockchain synchronization mechanism, calls the smart contract function to submit the final key exchange information, and the smart contract will verify whether the submitted information is valid. If it is valid, it will automatically send the transaction fee to the intermediate node.

[0094] Closing Phase: In this phase, if the receiving node can decrypt the encrypted data and obtain the original text by submitting information through the intermediate node, the message sending officially ends, and the intermediate node redeems its deposit. If the intermediate node fails to execute the actions specified in Phase Two of the encrypted data receiving phase before the deadline, the receiving node can obtain the deposit submitted by the intermediate node as compensation by using only a function in the smart contract.

[0095] In addition, the sending node possesses the signature public-private key pair (sk s , pk s The intermediate nodes possess public and private keys (y, x). The sending node's signature public and private keys are primarily used for signature generation and verification. The intermediate nodes possess encryption and decryption public and private keys to protect their own interests, and these keys satisfy the relationship y = g. x The specific implementation process will be detailed below:

[0096] Message sending phase

[0097] Assume the message to be sent is m and When a sender needs to send message m to a receiver, it first needs to send m to an intermediate node. After receiving m, the intermediate node performs the following steps:

[0098] 1. From Select a random number r from the group;

[0099] 2. Calculate the ciphertext c1 = g r and

[0100] 3. Use zero-knowledge proof techniques to generate a proof for the ciphertext (c1, c2).

[0101] 4. Send the proof along with the ciphertext (c1, c2) to the sender.

[0102] After receiving the proof and ciphertext (c1, c2), the recipient performs the following operations:

[0103] 1. Verify the ciphertext (c1, c2) based on the proof and message m.

[0104] 2. Verification successful. Calculate the corresponding hash value c of the ciphertext (c1, c2) using the SHA256 hash function. h = sha256(c1||c2);

[0105] 3. Using the signing private key sk s For hash value c h Signature to obtain δ c At the same time, δ c Send to intermediate node;

[0106] 4. Finally, call the smart contract's send function to record this message transmission.

[0107] After transmitting the corresponding data to the intermediate node, the sending node will deploy a smart contract to the blockchain system and call the send function, where the parameter c h The ciphertext hash value, parameter δ c This sends the node signature data; parameter y is the intermediate node's encryption public key, and parameter t... deadline This is the message sending deadline. The `broker` parameter is the intermediary address, and the `receiver` parameter is the receiver address. The pseudocode for the `Send` function is as follows: Figure 2 As shown.

[0108] The Send function can only be called by the sending node. Its main purpose is to build and deploy the contract required for the message and to prepay the transaction fee for sending the message.

[0109] Message relay stage

[0110] The intermediate node receives the ciphertext (c1, c2), random number r, message m, and corresponding signature δ sent by the sending node. c Then, perform the following operations:

[0111] 1. Calculate the hash value c corresponding to the ciphertext (c1, c2) using the SHA256 hash function. h = sha256(c1||c2)

[0112] 2. Through signature data δ c pk with the sending node's signature public key s For hash value c h Verification is required;

[0113] 3. After the signature verification is valid, use the equation c1 = g r and Verify whether the ciphertext is correctly encrypted;

[0114] If the verification is successful, the intermediate node will store the message and forward it to the receiving node's area, finally calling the smart contract's Forward function to store the deposit. Otherwise, no action is taken. The pseudocode for the Forward function is as follows: Figure 3 As shown, the Forward function can only be called by intermediate nodes. Its main purpose is to prevent intermediate nodes from launching malicious attacks and requires them to submit a partial deposit.

[0115] Encrypted data reception phase one

[0116] Upon reaching the area where the receiving node is located, the intermediate node will send the ciphertext (c1, c2) and the corresponding signature δ of the sending node. c Send to the receiving node. After receiving the message from the intermediate node, the receiving node performs the following operations:

[0117] 1. Calculate the hash value c corresponding to the ciphertext (c1, c2) using the SHA256 hash function. h = sha256(c1||c2)

[0118] 2. Through signature data δ c pk with the sending node's signature public key s For hash value c h Verify to confirm that the message actually originated from the sending node;

[0119] 3. If the verification is successful, then in Randomly select x′ from the middle;

[0120] 4. Calculation and

[0121] 5. The receiving node then calls the smart contract function Recive_1, where R and y′ are the values ​​calculated in step 4.

[0122] The pseudocode for the Recive_1 function is as follows: Figure 4 As shown, the Recive_1 function is called by the receiving node to exchange decryption keys via a smart contract peer-to-peer mechanism. Perform a validity check on R.

[0123] Second stage of encrypted data reception

[0124] Once the intermediate node learns through the blockchain system's consensus mechanism that the receiving node has successfully received and sent the data and triggered the smart contract Recive_1 function, it then performs the following operations:

[0125] 1. The intermediate node obtains R submitted by the receiving node from the smart contract and simultaneously calculates the temporary decryption key A = R. x ;

[0126] 2. Finally, the intermediate node calls the Receive_2 function in the smart contract, where parameter A is the value calculated in step 2. The pseudocode for the Receive_2 function is as follows: Figure 5 As shown.

[0127] The Receive_2 function is primarily used for decryption key exchange, and the smart contract communicates via equations. The validity of A is checked. Once the check passes, the smart contract will automatically send the corresponding transaction fee to the intermediary node, thereby protecting the interests of the intermediary node and promoting the development and operation of the latency-tolerant network.

[0128] Closure phase

[0129] After the receiving node discovers the temporary decryption key A submitted by the intermediate node through the blockchain synchronization mechanism, the receiving node will perform the following operations:

[0130] 1. The receiving node retrieves the temporary decryption key A from the smart contract, and then calculates...

[0131] 2. Then, use k to decrypt the ciphertext (c1, c2) to obtain the message m. The calculation steps are as follows:

[0132] If the intermediate node fails to send the temporary decryption key A to the smart contract within the specified time, the receiving node can call the smart contract's Close function to penalize the intermediate node. The pseudocode for the Close function is as follows: Figure 6 As shown.

[0133] If the intermediate node fails to provide the receiving node with a temporary decryption key within the specified time, the receiving node can call the Close function to request compensation. The smart contract will send the deposit stored by the intermediate node to the sending node as compensation. In addition, the intermediate node can also retrieve its deposit through this function.

[0134] It is understood that the present invention has been described through some embodiments, and those skilled in the art will recognize that various changes or equivalent substitutions can be made to these features and embodiments without departing from the spirit and scope of the invention. Furthermore, under the teachings of the present invention, these features and embodiments can be modified to adapt to specific situations and materials without departing from the spirit and scope of the invention. Therefore, the present invention is not limited to the specific embodiments disclosed herein, and all embodiments falling within the scope of the claims of this application are within the protection scope of the present invention.

Claims

1. A blockchain-based method for fair incentives in latency-tolerant networks, characterized in that, The process includes the message sending phase, message relay phase, encrypted data reception phase one, encrypted data reception phase two, and closing phase. The steps for each phase are as follows: The message sending phase is as follows: The sending node first sends the message to the intermediate node, which encrypts the message to be sent and generates a corresponding encrypted zero-knowledge proof; then, the intermediate node returns the ciphertext and the zero-knowledge proof to the sending node. After the sending node successfully verifies the ciphertext based on the proof, it deploys the smart contract and pre-stores the transaction fee therein. At the same time, it signs the ciphertext data and stores the corresponding signature and other information in the smart contract. The sending node possesses a signature public-private key pair (sk s ,pk s The intermediate node possesses a public-private key (y, x), the sending node's signature public-private key is used for signature generation and verification, and the intermediate node possesses an encryption / decryption public-private key, which satisfy the relationship y = g. x ; The message sending phase includes the following specific steps: Assume the message to be sent is m and When a sender needs to send message m to a receiver, it first sends m to an intermediate node. After receiving m, the intermediate node performs the following steps: A1: From Select a random number r from the group; A2: Calculate the ciphertext c1 = g r and A3: Use zero-knowledge proof techniques to generate a proof for the ciphertext (c1, c2); A4: Send the proof along with the ciphertext (c1, c2) to the sender; After receiving the proof and ciphertext (c1, c2), the recipient performs the following operations: B1: Verify the ciphertext (c1, c2) based on the proof and message m; B2: Verification successful. Calculate the corresponding hash value c of the ciphertext (c1, c2) using the SHA256 hash function. h = sha256(c1||c2); B3: Using the signing private key sk s For hash value c h Signature to obtain δ c At the same time, δ c Send to intermediate node; B4: Finally, the smart contract's Send function is called to record this message transmission; After transmitting the corresponding data to the intermediate node, the sending node deploys a smart contract to the blockchain system and calls the Send function. The Send function can only be called by the sending node and is used to build and deploy the contract required for the message and prepay the message sending fee. The message relay stage: After the intermediate node obtains the relevant message through the smart contract, it first verifies the message based on the signature, encrypted data and the public key of the sending node. If the verification is successful, it stores the message and sends it to the area where the receiving node is located. At the same time, the intermediate node sends a deposit to the smart contract. The first stage of receiving encrypted data: After the intermediate node arrives at the area where the receiving node is located, it forwards the stored encrypted and signature data to the receiving node through a temporary communication channel established with the receiving node; The receiving node also verifies the encrypted data. If the verification is successful, it calls the smart contract function to exchange the decryption key. The second stage of receiving encrypted data: The intermediate node learns about the data sent by the receiving node through the blockchain synchronization mechanism, calls the smart contract function to submit the final key exchange information, and the smart contract will verify whether the submitted information is valid. If it is valid, it will automatically send the transaction fee to the intermediate node. The closing phase: If the receiving node can decrypt the encrypted data and obtain the original text by submitting information through the intermediate node, the message sending officially ends, and the intermediate node redeems the deposit at the same time. If the intermediate node fails to execute the actions specified in Phase 2 of the encrypted data reception before the deadline, the receiving node can obtain the deposit submitted by the intermediate node as compensation by simply using a function in the smart contract.

2. The blockchain-based fair incentive method for latency-tolerant networks according to claim 1, characterized in that, The message relay stage includes the following specific steps: The intermediate node obtains the corresponding signature δ of the sending node for message m through a smart contract. c Then, perform the following operations: C1: Calculate the hash value c corresponding to the ciphertext (c1, c2) using the sha256 hash function. h = sha256(c1||c2) C2: Through signature data δ c pk with the sending node's signature public key s For hash value c h Verification is required; C3: After the signature verification is valid, use the equation c1 = g r and Verify whether the ciphertext is correctly encrypted; If the verification is successful, the intermediate node will store the message and proceed to the receiving node's area. Finally, it will call the smart contract's Forward function to store the deposit. Otherwise, it will do nothing. The Forward function can only be called by intermediate nodes to prevent them from submitting a portion of the deposit if they launch a malicious attack.

3. The blockchain-based fair incentive method for latency-tolerant networks according to claim 1, characterized in that, The first stage of receiving encrypted data includes the following specific steps: Upon reaching the area where the receiving node is located, the intermediate node will send the ciphertext (c1, c2) and the corresponding signature δ from the sending node. c The message is sent to the receiving node. After receiving the message from the intermediate node, the receiving node performs the following operations: D1: Calculate the hash value c corresponding to the ciphertext (c1, c2) using the SHA256 hash function. h ′=sha256(c1||c2); D2: Through signature data δ c pk with the sending node's signature public key s For hash value c h Verify to confirm that the message actually originated from the sending node; D3: If verification is successful, then in Randomly select x ′ ; D4: Calculation and Subsequently, the receiving node calls the smart contract function Recive_1. This function, called by the receiving node, is used to exchange decryption keys via a peer-to-peer smart contract. Perform a validity check on R.

4. The blockchain-based fair incentive method for latency-tolerant networks according to claim 1, characterized in that, The second stage of receiving encrypted data includes the following specific steps: Once the intermediate node learns through the blockchain system's consensus mechanism that the receiving node has successfully received and sent the data and triggered the smart contract Recive_1 function, it then performs the following operations: E1: The intermediate node obtains R submitted by the receiving node from the smart contract and simultaneously calculates the temporary decryption key A = R. x ; E2: Finally, the intermediate node calls the Receive_2 function in the smart contract. The Receive_2 function is used to exchange decryption keys, and the smart contract uses equations... The validity of A is checked. Once the check passes, the smart contract will automatically send the corresponding transaction fee to the intermediate node, thereby protecting the interests of the intermediate node and promoting the development and operation of the latency-tolerant network.

5. The blockchain-based fair incentive method for latency-tolerant networks according to claim 1, characterized in that, The shutdown phase includes the following specific steps: After discovering the temporary decryption key A submitted by the intermediate node through the blockchain synchronization mechanism, the receiving node performs the following operations: F1: The receiving node retrieves the temporary decryption key A from the smart contract, and then calculates... F2: Then, use k to decrypt the ciphertext (c1, c2) to obtain the message m. The calculation steps are as follows: If the intermediate node fails to send the temporary decryption key A to the smart contract within the specified time, the receiving node can call the smart contract's Close function to punish the intermediate node. If the intermediate node fails to provide the receiving node with a temporary decryption key within the specified time, the receiving node calls the Close function to request compensation. The smart contract sends the deposit stored by the intermediate node to the sending node as compensation, and the intermediate node retrieves the deposit through the Close function.

Images