目录
[1.1 Merkle Tree可信树](#1.1 Merkle Tree可信树)
[1.2 源码实现：](#1.2 源码实现：)
[1.3 哈希计算功能](#1.3 哈希计算功能)
[1.4 两种算法的区别：](#1.4 两种算法的区别：)
[1.4.1 目的](#1.4.1 目的)
[1.4.2 实现机制](#1.4.2 实现机制)
[1.4.3 输出](#1.4.3 输出)
[1.4.4 应用场景：](#1.4.4 应用场景：)
[1.4 运行演示：](#1.4 运行演示：)
[2.2 比特币挖矿与工作量证明](#2.2 比特币挖矿与工作量证明)
[2.3 安全性](#2.3 安全性)
[2.4 SHA-2算法概述](#2.4 SHA-2算法概述)
[2.4.1. 消息填充](#2.4.1. 消息填充)
[2.4.2 初始化链接变量缓冲区（SHA-256）](#2.4.2 初始化链接变量缓冲区（SHA-256）)
[2.4.3 SHA-512 处理](#2.4.3 SHA-512 处理)
[2.4.4 SHA-384 和 SHA-512 的迭代函数](#2.4.4 SHA-384 和 SHA-512 的迭代函数)
[3.1 区块的结构](#3.1 区块的结构)
[3.2. 挖矿过程](#3.2. 挖矿过程)
[3.3 TARGET 的计算](#3.3 TARGET 的计算)
[3.4 源码演示](#3.4 源码演示)
[3.5 算法思路](#3.5 算法思路)
[1. 目标定义:](#1. 目标定义:)
[2. 数据准备:](#2. 数据准备:)
[3. 哈希计算:](#3. 哈希计算:)
[4. 有效性检查:](#4. 有效性检查:)
[5. 输出结果:](#5. 输出结果:)
一、SHA-1算法分析：
安全散列算法是一种加密散列函数，生成固定长度的散列值（或摘要），用于确保数据完整性和验证数据的真实性。
SHA-1是SHA系列中的一种，产生160比特（20字节）的散列值。其散列值通常表示为40个十六进制字符。SHA-1的散列值格式为`H0 H1 H2 H3 H4`，每个部分代表散列的不同部分。
尽管SHA-1曾被广泛使用，但它已经被证明存在弱点，尤其是对碰撞攻击的脆弱性。在2005年，研究人员王小云成功攻破了SHA-1，展示了其产生相同散列值的可能性，这就是所谓的**"碰撞"**。消息摘要是通过散列函数生成的数据摘要，它是输入数据的唯一表示。消息摘要用于确保数据在传输或存储过程中未被篡改。
**MD4是早期的散列算法，而MD5是由MD4算法衍生而来。**MD5生成128比特的散列值，广泛用于数据完整性校验，但同样也被发现存在安全漏洞。SHA系列，特别是SHA-1，确实是受到MD4的影响。尽管SHA-1和MD5具有不同的结构和输出长度，但它们在设计理念上有相似之处。
1.1 Merkle Tree可信树
Merkle树是一种哈希树，叶子节点代表数据块（如交易）的哈希值，而非叶子节点的哈希值则是其子节点哈希值的组合。
Merkle树的底部是交易的哈希（即叶子节点），而每对叶子节点的哈希值会组合成其父节点的哈希，直到最终形成根哈希（Merkle根）。这个根哈希代表了整个树的所有交易摘要。
在比特币中，交易哈希使用双SHA-256哈希算法进行计算。即每一笔交易在生成哈希时，首先计算SHA-256哈希，然后再对该哈希值计算一次SHA-256，从而增强安全性。
1.2 源码实现：
cpp
#include <iostream> // 引入输入输出流库，以便使用 cout 和 cerr
#include <openssl/md5.h> // 引入 OpenSSL 的 MD5 相关函数
#include <openssl/sha.h> // 引入 OpenSSL 的 SHA 相关函数
#include <fstream> // 引入文件流库，以便读取文件
#include <iomanip> // 引入用于格式化输入输出的库，例如设置输出宽度
#include <thread> // 引入线程库，以便使用睡眠功能
#include <vector> // 引入 STL 的 vector 容器
using namespace std; // 使用标准命名空间，方便后续使用标准库中的元素
// 计算文件的MD5哈希值
string GetFileListHash(const string& filepath)
{
// 以二进制方式打开文件
ifstream ifs(filepath, ios::binary); // 创建文件流对象以二进制模式打开指定路径的文件
if (!ifs) { // 检查文件是否成功打开
cerr << "Failed to open file: " << filepath << endl; // 输出错误信息到标准错误流
return ""; // 返回空字符串表示失败
}
int block_size = 128; // 定义一次读取的块大小为 128 字节
unsigned char buf[block_size] = { 0 }; // 创建一个缓冲区用于存放读取的数据，初始化为 0
unsigned char out[MD5_DIGEST_LENGTH] = { 0 }; // 创建输出数组，用于存放 MD5 哈希结果
MD5_CTX c; // 定义 MD5 上下文结构体
MD5_Init(&c); // 初始化 MD5 上下文
while (!ifs.eof()) { // 当文件没有到达末尾时循环
ifs.read(reinterpret_cast<char*>(buf), block_size); // 从文件中读取数据到 buf 缓冲区
int read_size = ifs.gcount(); // 获取实际读取的字节数
if (read_size > 0) { // 如果读取的字节数大于 0
MD5_Update(&c, buf, read_size); // 将读取的数据更新到 MD5 上下文中
}
}
MD5_Final(out, &c); // 完成 MD5 计算并将结果存入 out 数组
ifs.close(); // 关闭文件流
return string(reinterpret_cast<char*>(out), MD5_DIGEST_LENGTH); // 将 MD5 结果转换为字符串并返回
}
// 文件可信树 Hash
std::string GetFileMerkleHash(std::string filepath) {
std::string hash; // 定义哈希字符串
std::vector<std::string> hashes; // 定义一个字符串向量用于存放中间哈希值
std::ifstream ifs(filepath, std::ios::binary); // 以二进制方式打开文件
if (!ifs) return hash; // 如果文件未打开，返回空哈希值
unsigned char buf[1024] = { 0 }; // 创建缓冲区用于读取文件数据
unsigned char out[SHA_DIGEST_LENGTH]; // 创建输出数组，用于存放 SHA1 哈希结果
int block_size = 128; // 定义一次读取的块大小为 128 字节
while (!ifs.eof()) { // 当文件没有到达末尾时循环
ifs.read(reinterpret_cast<char*>(buf), block_size); // 从文件中读取数据到 buf
int read_size = ifs.gcount(); // 获取实际读取的字节数
if (read_size <= 0) break; // 如果没有读取到数据，跳出循环
SHA1(buf, read_size, out); // 计算 SHA1 哈希并存储到 out 数组中
hashes.push_back(std::string(reinterpret_cast<char*>(out), SHA_DIGEST_LENGTH)); // 将哈希值转换为字符串并添加到 hashes 向量中
}
// 计算 Merkle 哈希
while (hashes.size() > 1) { // 当 hashes 向量中有多个哈希值时
if (hashes.size() & 1) { // 如果 hashes 的大小是奇数
hashes.push_back(hashes.back()); // 将最后一个哈希值复制一份到末尾，保证成对
}
for (size_t i = 0; i < hashes.size() / 2; i++) { // 遍历哈希值的成对组合
std::string tmp_hash = hashes[i * 2]; // 获取第一个哈希值
tmp_hash += hashes[i * 2 + 1]; // 拼接第二个哈希值
SHA1(reinterpret_cast<const unsigned char*>(tmp_hash.data()), tmp_hash.size(), out); // 计算拼接后字符串的 SHA1 哈希
hashes[i] = std::string(reinterpret_cast<char*>(out), SHA_DIGEST_LENGTH); // 更新哈希值到 hashes 向量
}
hashes.resize(hashes.size() / 2); // 将 hashes 向量的大小减半
}
if (hashes.size() == 0) return hash; // 如果 hashes 向量为空，返回空哈希值
return hashes[0]; // 返回 Merkle 树的根哈希值
}
// 以十六进制格式输出数据
void PrintHex(const string& data) {
for (unsigned char c : data) { // 遍历数据中的每一个字节
cout << hex << setw(2) << setfill('0') << (int)c; // 将每个字节以十六进制格式输出
}
cout << endl; // 输出换行符
}
int main() {
cout << "Test Hash" << endl; // 输出测试信息
unsigned char data[] = "测试MD5数据"; // 定义要进行MD5哈希的数据
unsigned char out[MD5_DIGEST_LENGTH] = { 0 }; // 创建输出数组，用于存放 MD5 哈希结果
int len = sizeof(data) - 1; // 计算数据长度，减去 1 是因为 sizeof 包含字符串末尾的 '\0'
// 对数据进行 MD5 哈希计算
MD5(data, len, out); // 计算 MD5 哈希
// 输出哈希结果
for (int i = 0; i < MD5_DIGEST_LENGTH; i++) { // 遍历哈希结果
cout << hex << setw(2) << setfill('0') << (int)out[i]; // 输出哈希值的每一个字节
}
cout << endl; // 输出换行符
data[1] = 9; // 修改数据
MD5(data, len, out); // 再次计算 MD5 哈希
for (int i = 0; i < MD5_DIGEST_LENGTH; i++) { // 遍历哈希结果
cout << hex << setw(2) << setfill('0') << (int)out[i]; // 输出新的哈希值
}
cout << endl; // 输出换行符
string filepath = "/home/book/Desktop/test.txt"; // 指定要读取的文件路径
auto hash1 = GetFileListHash(filepath); // 计算文件的 MD5 哈希值
PrintHex(hash1); // 输出文件的哈希值
for (;;) { // 无限循环
auto hash = GetFileListHash(filepath); // 重新计算文件哈希值
auto thash = GetFileMerkleHash(filepath); // 计算文件的 Merkle 哈希值
if (hash != hash1) { // 如果文件哈希值与之前的哈希不相等
cout << "文件被修改" << endl; // 输出文件被修改的警告
cout << "HashList:\t"; // 输出哈希列表的提示
PrintHex(hash); // 输出新的哈希值
hash1 = hash; // 更新之前的哈希值
cout << "MerkleTree:\t"; // 输出 Merkle 树的提示
PrintHex(thash); // 输出 Merkle 哈希值
}
this_thread::sleep_for(chrono::seconds(1)); // 每秒检查一次
}
return 0; // 程序正常结束
}makefile
bash
first_openss:test_openssl.cpp
g++ $^ -o $@ -I/usr/local/include -L/usr/local/lib -lcrypto -std=c++111.3 哈希计算功能
1. MD5 哈希计算 (GetFileListHash 函数)
- 该函数用于计算指定文件的 MD5 哈希值。
- 以二进制模式打开文件，逐块读取文件数据（128 字节为一块），并将读取的数据传递给 MD5 上下文进行更新。
- 文件读取完成后，调用
MD5_Final完成哈希计算，并返回哈希值。
2. Merkle 哈希计算 (GetFileMerkleHash 函数)
- 该函数实现了基于文件内容的 Merkle 树哈希计算。
- 逐块读取文件数据，并对每一块数据计算 SHA-1 哈希，存储在一个
std::vector中。 - 通过将相邻的哈希值成对拼接并计算新的 SHA-1 哈希，逐步构建 Merkle 树，直到只剩下一个根哈希。
1.4 两种算法的区别：
1.4.1 目的
（1）. MD5 哈希计算 (GetFileListHash 函数)
- 主要用于生成文件的唯一标识符（哈希值），以便快速验证文件内容的完整性。
- 当文件内容发生变化时，MD5 哈希值会变化，从而可以用于检测文件是否被修改。
（2）. Merkle 哈希计算 (GetFileMerkleHash 函数)
- 主要用于构建 Merkle 树，提供一种结构化的方法来验证数据完整性和一致性。
- Merkle 树允许验证文件中的特定部分（例如，分块数据），并且在分布式系统（如区块链）中非常常见，能够支持高效的证明和检查。
1.4.2 实现机制
（1）. MD5 哈希计算
- 整个文件数据一次性地计算一个 MD5 哈希值。
- 逐块读取文件（每块 128 字节），将读取到的数据传递到 MD5 上下文进行更新。
- 最终通过调用
MD5_Final完成哈希计算，返回一个固定大小的 128 位（16 字节）MD5 哈希值。
（2）. Merkle 哈希计算
- 将文件分成多个块，对每个块计算 SHA-1 哈希，得到每个块的哈希值，并将它们存储在一个向量中。
- 接着，将相邻的哈希值成对拼接，计算新的 SHA-1 哈希，重复这个过程，最终构建出一个根哈希（Merkle 根）。
- 这一过程允许逐渐合并和验证多个哈希，能够高效地构建树状结构，有助于快速验证数据的完整性。
1.4.3 输出
（1）. MD5 哈希计算：
- 输出的结果是一个单一的 MD5 哈希值，通常以十六进制字符串形式表示。
（2）. Merkle 哈希计算
- 输出的是一个根哈希值（Merkle 根），它代表了整个文件内容的哈希结构，可以视为整个文件的完整唯一标识。
1.4.4 应用场景：
（1）. MD5 哈希计算 更加简单，主要用于快速验证文件是否已被修改，适合单一文件检查。
（2）. Merkle 哈希计算 则更复杂，适用于需要验证数据完整性和一致性的场景，尤其是当涉及多个数据块或分布式系统时。它通过构建树形结构提高了数据验证的效率和灵活性。
1.4 运行演示：
二、SHA-2算法分析：
**SHA-256、SHA-384 和 SHA-512 是三种不同的安全哈希算法，它们都是 SHA-2（安全哈希算法2）系列的一部分。**它们在比特币挖矿的工作量证明（Proof of Work）机制中扮演着重要角色。
2.1哈希算法简介
1. SHA-256:
- 输出长度：256位（32字节）。
- 是比特币网络中使用的主要哈希函数。
- 具有较强的安全性，目前尚未发现有效的攻击方式。
2. SHA-384:
- 输出长度：384位（48字节）。
- 通常用于需要更高安全性要求的场合，但在比特币挖矿中并不常用。
3. SHA-512:
- 输出长度：512位（64字节）。
- 也提供了较高的安全性和抗碰撞能力，适用于对数据完整性有极高要求的应用场景。
2.2 比特币挖矿与工作量证明
1. 工作量证明机制:
- 在比特币网络中，工作量证明是用于验证和确认交易的一种机制。矿工通过计算哈希值来竞争生成新区块。
- 矿工需要找到一个满足特定条件的哈希值（即小于某个目标值）。为此，他们会不断调整输入数据（包括随机数 nonce）并计算哈希，直到找到符合条件的哈希值。
2. SHA-256 在比特币挖矿中的应用:
- 比特币挖矿主要使用 SHA-256 算法。矿工通过对区块头信息应用 SHA-256 哈希，试图找到一个符合难度目标的哈希值。
- 挖矿的过程是一个计算密集型的过程，不断地尝试生成一个新的哈希值，每一次尝试都需要消耗计算资源。这也是导致比特币挖矿需要大量电力和硬件资源的原因。
2.3 安全性
- 目前，SHA-2 系列（包括 SHA-256、SHA-384 和 SHA-512）尚未被成功攻克。尽管 SHA-1 在安全性上已被广泛认为不再安全，但 SHA-2 仍然被认为是安全的。
- 这些哈希算法能够有效防止碰撞攻击（即不可能找到两个不同的输入生成相同的哈希值），并且提供良好的抗预映射攻击（即从哈希值推断出原始输入的难度）。
2.4 SHA-2算法概述
2.4.1. 消息填充
在 SHA 系列哈希算法中，消息填充是将输入消息调整到特定长度的过程，以便满足算法处理的要求。
消息填充模 512 与 448 同余:
（1）SHA-256 和 SHA-512 都采用类似的填充机制，以确保输入消息的长度在处理之前符合特定要求。
（2）消息的长度在被填充后，需要满足以下条件：
填充后的消息长度要对 512 取模 ，且填充后的长度要为 448 位，即填充后的消息长度为 𝐿 ≡ 448 mod 512。
填充过程一般是**先添加一个 "1" 位（0x80），然后添加足够的 "0" 位，使得消息长度（以比特为单位）达到 448 位。**最后，附加一个 64 位的表示原始消息长度的值，确保最终的消息长度是 512 位的整数倍。
2.4.2 初始化链接变量缓冲区（SHA-256）
SHA-256 初始化时使用 8 个 32 位的寄存器，这些寄存器通常称为链值（chain values），用于存储哈希计算的中间结果。
链接变量：
这些链接变量的初始值取自前 8 个素数的平方根的小数部分，具体是：2、3、5、7、11、13、17、19 的平方根小数部分的前 32 位二进制表示。
初始值为：
- h0=6a09e667
- ℎ1=𝑏𝑏67𝑎𝑒85
- ℎ2=3𝑐6𝑒𝑓372
- ℎ3=𝑎54𝑓𝑓53𝑎
- ℎ4=510𝑒527𝑓
- ℎ5=9𝑏05688𝑐
- ℎ6=1𝑓83𝑑9𝑎𝑏
- ℎ7=5𝑏𝑒0𝑐𝑑19
2.4.3 SHA-512 处理
SHA-512 和 SHA-256 相似，但使用的是 64 位的寄存器，并以 1024 位（128 字节）为一个分组进行处理。
初始化链接变量:
SHA-512 使用 8 个 64 位的寄存器，初始化值取自前 8 个素数的平方根小数部分的前 64 位二进制表示。
分组和循环:
SHA-512 将输入消息分成 1024 位的块进行处理，每个块经过 80 轮的迭代（与 SHA-256 的 64 轮相比，SHA-512 具有更多的迭代）。
每一轮都使用特定的计算函数（如选择、置换等）和常数值，对每个分组进行复杂的运算。
2.4.4 SHA-384 和 SHA-512 的迭代函数
SHA-384 和 SHA-512 虽然在位数和寄存器大小上有所不同，但它们也都使用了 6 个迭代函数来处理输入块。
- Ch（选择）：根据条件选择输入位。
- Maj（多数）：计算三个输入位的多数。
- Σ0 和 Σ1：旋转和位移操作，用于产生混淆和扩散。
- σ0 和 σ1：类似于 Σ，但在处理中使用不同的旋转和位移位数。
三、模拟比特币挖矿
3.1 区块的结构
一个区块包含多个字段，每个字段在挖矿过程中都有特定的作用：
**（1）版本（version）:**表示区块的版本号，提供了协议的版本信息，可能影响区块的创建或验证方式。
**（2）上一个区块的哈希值（prev_hash）:**这是前一个区块的 SHA-256 哈希值，用于连接区块链。确保每个区块都有效地链接到前一个区块，形成不可篡改的链条。
**（3）交易记录的哈希树值（merkle_root）:**这是当前区块中所有交易的 Merkle 树根哈希，提供了一种高效验证区块内所有交易是否被篡改的方式。
**（4）更新时间（ntime）：**该字段记录当前区块创建的时间戳，通常以 Unix 时间戳表示。
**（5）当前难度（nbits）：**该字段表示目标的难度级别，影响挖矿时需要找到的哈希值的范围。
3.2. 挖矿过程
挖矿过程的核心是找到一个有效的 nonce 值，使得生成的区块哈希满足特定的难度目标。
1. 构造区块头:
区块头由以下字段组成：
versionprev_hashmerkle_rootntimenbitsnonce（初始值为 0）
2. 计算哈希:
使用 SHA-256 两次对区块头进行哈希计算：
这里的 `||` 表示将各个字段串联在一起。
3. 比较哈希与目标:
计算出的哈希值需要与一个预定义的目标（TARGET）进行比较。
如果计算出的哈希值小于或等于 TARGET，则该 nonce 是有效的，矿工成功找到一个有效的区块。
4. 调整难度:
TARGET 由当前难度决定，难度会根据网络的算力变化而调整，以确保新区块的生成时间大约为 10 分钟。TARGET 的计算公式通常与 nbits 相关。
3.3 TARGET 的计算
TARGET 可以根据当前的难度 (nbits) 计算得出：
nbits 是一个表示难度的 32 位数字，通常以十六进制表示，前面的字节用于表示目标的位数（例如，00000000），后面的部分表示目标值的具体大小（例如，FFFF）。
计算出的 TARGET 值越小，挖矿难度越高。
比特币挖矿的过程涉及到多个关键的区块字段和复杂的哈希计算，以确保区块链的安全性和完整性。矿工通过不断尝试不同的 nonce 值，来寻找满足当前难度目标的有效哈希值，以便成功添加新区块到区块链中。
3.4 源码演示
cpp
#include <iostream> // 引入输入输出流库，以便使用 cout 和 cerr
#include <openssl/md5.h> // 引入 OpenSSL 的 MD5 相关函数
#include <openssl/sha.h> // 引入 OpenSSL 的 SHA 相关函数
#include <fstream> // 引入文件流库，以便读取文件
#include <iomanip> // 引入用于格式化输入输出的库，例如设置输出宽度
#include <thread> // 引入线程库，以便使用睡眠功能
#include <vector> // 引入 STL 的 vector 容器
#include <cstring> // 引入 C 字符串库，以便使用 strlen 和 memcpy
using namespace std; // 使用标准命名空间，方便后续使用标准库中的元素
void TestBit() // 定义 TestBit 函数
{
unsigned char data[128] = "测试比特币挖矿，模拟交易链"; // 定义一个字符数组并初始化为测试字符串
unsigned int nonce = 0; // 定义 nonce 变量并初始化为 0，用于寻找有效 nonce
int data_size = strlen((char*)data); // 获取数据大小，返回字符串的长度
unsigned char md1[1024] = { 0 }; // 定义 md1 数组用于存储第一次 SHA-256 哈希结果，初始化为 0
unsigned char md2[1024] = { 0 }; // 定义 md2 数组用于存储第二次 SHA-256 哈希结果，初始化为 0
for (;;) // 无限循环，直到找到满足条件的 nonce
{
nonce++; // 增加 nonce 值
memcpy(data + data_size, &nonce, sizeof(nonce)); // 将当前 nonce 值复制到 data 数组的末尾
SHA256(data, data_size + sizeof(nonce), md1); // 计算 data 的 SHA-256 哈希，结果存入 md1
SHA256(md1, 64, md2); // 计算 md1 的 SHA-256 哈希，结果存入 md2
//工作量的难度
if (md2[0] == 0) break; // 如果 md2 的第一个字节为 0，则跳出循环
}
cout << "nonce = " << nonce << endl; // 输出找到的 nonce 值
}
int main() { // 主函数入口
cout << "Test Bit" << endl; // 输出测试信息
TestBit(); // 调用 TestBit 函数
return 0; // 程序正常结束
}运行效果：
当我们增加难度以后：
cpp
if (md2[0] == 0) break;//原代码难度
if (md2[0] == 0 && md2[1] == 0) break;//修改代码难度再次运行效果：
3.5 算法思路
1. 目标定义:
挖矿的目标是**找到一个满足特定条件的哈希值。**在比特币网络中，通常是使得哈希值的前面若干位为零。这个条件可以通过调整 nonce 值来实现。
2. 数据准备:
挖矿过程中，矿工需要准备一个数据块**，****这个数据块通常包含交易信息、时间戳、前一个区块的哈希值等。**在这里，代码使用了一个简单的字符串 "测试比特币挖矿，模拟交易链" 作为基础数据。
nonce 是一个用于生成哈希值的随机数，它会随着每次尝试而变化。
3. 哈希计算:
使用SHA-256 哈希算法对数据进行多次哈希计算。在每次尝试中，程序将当前的 nonce 值附加到数据块中，然后计算哈希值。
具体流程如下：
（1）计算当前数据块的哈希（SHA256(data)），这个哈希值存储在 md1 中。
（2）再对 md1 进行一次哈希（SHA256(md1)），结果存储在 md2 中。这个双重哈希的目的是增加安全性和复杂性。
4. 有效性检查:
在每次哈希计算后，检查 md2 的第一个字节是否为 0。如果满足条件，说明找到了符合挖矿要求的哈希值，程序就可以停止查找。
5. 输出结果:
一旦找到了有效的 nonce，程序会将其打印输出。这告诉矿工他们成功地找到了一个有效的哈希。
总结：
- 初始化 : 准备数据和
nonce，计算数据的初始大小。- 循环尝试 : 通过无限循环，不断增加
nonce值，更新数据，计算哈希。- 哈希计算: 每次尝试都计算两次哈希值，增加难度和安全性。
- 条件检查: 检查计算出的哈希值是否满足特定条件以决定是否继续。
- 结果输出 : 找到有效
nonce后打印结果。- 暴力搜索 : 这个算法实际上是一种暴力搜索策略。通过不断尝试不同的
nonce值，直到找到一个合适的哈希值。这是挖矿过程中常见的做法。- 安全性和复杂性: 通过双重哈希计算，增加了找到哈希的复杂性和安全性，防止简单的逆向工程和破解。
- 分布式系统特性: 由于比特币网络是去中心化的，许多矿工在全球范围内同时进行这个过程，从而竞争解决问题并获得奖励。