devbox
小惠珠哦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【常见开源库的二次开发】基于openssl的加密与解密——SHA算法源码解析（六）_openssl sha256 源码

作者：小惠珠哦 | 2024-07-30 20:42:07

赞

踩

openssl sha256 源码

目录

一、SHA-1算法分析：

1.1 Merkle Tree可信树

1.2 源码实现：

1.3 哈希计算功能

1.4 两种算法的区别： 

1.4.1 目的

 1.4.2 实现机制

1.4.3 输出

1.4.4 应用场景：

1.4 运行演示：

二、SHA-2算法分析： 

2.1哈希算法简介 

 2.2 比特币挖矿与工作量证明

2.3 安全性 

 2.4 SHA-2算法概述

2.4.1. 消息填充

2.4.2 初始化链接变量缓冲区（SHA-256）

2.4.3 SHA-512 处理

2.4.4 SHA-384 和 SHA-512 的迭代函数

 三、模拟比特币挖矿

3.1 区块的结构

3.2. 挖矿过程

3.3 TARGET 的计算

3.4 源码演示

 3.5 算法思路

1. 目标定义:

2. 数据准备:

3. 哈希计算:

4. 有效性检查:

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 源码实现：

  1. #include <iostream> // 引入输入输出流库，以便使用 cout 和 cerr
  2. #include <openssl/md5.h> // 引入 OpenSSL 的 MD5 相关函数
  3. #include <openssl/sha.h> // 引入 OpenSSL 的 SHA 相关函数
  4. #include <fstream> // 引入文件流库，以便读取文件
  5. #include <iomanip> // 引入用于格式化输入输出的库，例如设置输出宽度
  6. #include <thread> // 引入线程库，以便使用睡眠功能
  7. #include <vector> // 引入 STL 的 vector 容器
  8.  
  9. using namespace std; // 使用标准命名空间，方便后续使用标准库中的元素
  10.  
  11. // 计算文件的MD5哈希值
  12. string GetFileListHash(const string& filepath)
  13. {
  14.     // 以二进制方式打开文件
  15.     ifstream ifs(filepath, ios::binary); // 创建文件流对象以二进制模式打开指定路径的文件
  16.     if (!ifs) { // 检查文件是否成功打开
  17.         cerr << "Failed to open file: " << filepath << endl; // 输出错误信息到标准错误流
  18.         return ""; // 返回空字符串表示失败
  19.     }
  20.  
  21.     int block_size = 128; // 定义一次读取的块大小为 128 字节
  22.     unsigned char buf[block_size] = { 0 }; // 创建一个缓冲区用于存放读取的数据，初始化为 0
  23.     unsigned char out[MD5_DIGEST_LENGTH] = { 0 }; // 创建输出数组，用于存放 MD5 哈希结果
  24.  
  25.     MD5_CTX c; // 定义 MD5 上下文结构体
  26.     MD5_Init(&c); // 初始化 MD5 上下文
  27.  
  28.     while (!ifs.eof()) { // 当文件没有到达末尾时循环
  29.         ifs.read(reinterpret_cast<char*>(buf), block_size); // 从文件中读取数据到 buf 缓冲区
  30.         int read_size = ifs.gcount(); // 获取实际读取的字节数
  31.         if (read_size > 0) { // 如果读取的字节数大于 0
  32.             MD5_Update(&c, buf, read_size); // 将读取的数据更新到 MD5 上下文中
  33.         }
  34.     }
  35.  
  36.     MD5_Final(out, &c); // 完成 MD5 计算并将结果存入 out 数组
  37.     ifs.close(); // 关闭文件流
  38.  
  39.     return string(reinterpret_cast<char*>(out), MD5_DIGEST_LENGTH); // 将 MD5 结果转换为字符串并返回
  40. }
  41.  
  42. // 文件可信树 Hash
  43. std::string GetFileMerkleHash(std::string filepath) {
  44.     std::string hash; // 定义哈希字符串
  45.     std::vector<std::string> hashes; // 定义一个字符串向量用于存放中间哈希值
  46.     std::ifstream ifs(filepath, std::ios::binary); // 以二进制方式打开文件
  47.  
  48.     if (!ifs) return hash; // 如果文件未打开，返回空哈希值
  49.  
  50.     unsigned char buf[1024] = { 0 }; // 创建缓冲区用于读取文件数据
  51.     unsigned char out[SHA_DIGEST_LENGTH]; // 创建输出数组，用于存放 SHA1 哈希结果
  52.  
  53.     int block_size = 128; // 定义一次读取的块大小为 128 字节
  54.     while (!ifs.eof()) { // 当文件没有到达末尾时循环
  55.         ifs.read(reinterpret_cast<char*>(buf), block_size); // 从文件中读取数据到 buf
  56.         int read_size = ifs.gcount(); // 获取实际读取的字节数
  57.         if (read_size <= 0) break; // 如果没有读取到数据，跳出循环
  58.  
  59.         SHA1(buf, read_size, out); // 计算 SHA1 哈希并存储到 out 数组中
  60.         hashes.push_back(std::string(reinterpret_cast<char*>(out), SHA_DIGEST_LENGTH)); // 将哈希值转换为字符串并添加到 hashes 向量中
  61.     }
  62.  
  63.     // 计算 Merkle 哈希
  64.     while (hashes.size() > 1) { // 当 hashes 向量中有多个哈希值时
  65.         if (hashes.size() & 1) { // 如果 hashes 的大小是奇数
  66.             hashes.push_back(hashes.back()); // 将最后一个哈希值复制一份到末尾，保证成对
  67.         }
  68.  
  69.         for (size_t i = 0; i < hashes.size() / 2; i++) { // 遍历哈希值的成对组合
  70.             std::string tmp_hash = hashes[i * 2]; // 获取第一个哈希值
  71.             tmp_hash += hashes[i * 2 + 1]; // 拼接第二个哈希值
  72.             SHA1(reinterpret_cast<const unsigned char*>(tmp_hash.data()), tmp_hash.size(), out); // 计算拼接后字符串的 SHA1 哈希
  73.             hashes[i] = std::string(reinterpret_cast<char*>(out), SHA_DIGEST_LENGTH); // 更新哈希值到 hashes 向量
  74.         }
  75.         hashes.resize(hashes.size() / 2); // 将 hashes 向量的大小减半
  76.     }
  77.  
  78.     if (hashes.size() == 0) return hash; // 如果 hashes 向量为空，返回空哈希值
  79.     return hashes[0]; // 返回 Merkle 树的根哈希值
  80. }
  81.  
  82. // 以十六进制格式输出数据
  83. void PrintHex(const string& data) {
  84.     for (unsigned char c : data) { // 遍历数据中的每一个字节
  85.         cout << hex << setw(2) << setfill('0') << (int)c; // 将每个字节以十六进制格式输出
  86.     }
  87.     cout << endl; // 输出换行符
  88. }
  89.  
  90. int main() {
  91.     cout << "Test Hash" << endl; // 输出测试信息
  92.  
  93.     unsigned char data[] = "测试MD5数据"; // 定义要进行MD5哈希的数据
  94.     unsigned char out[MD5_DIGEST_LENGTH] = { 0 }; // 创建输出数组，用于存放 MD5 哈希结果
  95.     int len = sizeof(data) - 1; // 计算数据长度，减去 1 是因为 sizeof 包含字符串末尾的 '\0'
  96.  
  97.     // 对数据进行 MD5 哈希计算
  98.     MD5(data, len, out); // 计算 MD5 哈希
  99.     // 输出哈希结果
  100.     for (int i = 0; i < MD5_DIGEST_LENGTH; i++) { // 遍历哈希结果
  101.         cout << hex << setw(2) << setfill('0') << (int)out[i]; // 输出哈希值的每一个字节
  102.     }
  103.     cout << endl; // 输出换行符
  104.  
  105.     data[1] = 9; // 修改数据
  106.     MD5(data, len, out); // 再次计算 MD5 哈希
  107.     for (int i = 0; i < MD5_DIGEST_LENGTH; i++) { // 遍历哈希结果
  108.         cout << hex << setw(2) << setfill('0') << (int)out[i]; // 输出新的哈希值
  109.     }
  110.     cout << endl; // 输出换行符
  111.  
  112.     string filepath = "/home/book/Desktop/test.txt"; // 指定要读取的文件路径
  113.     auto hash1 = GetFileListHash(filepath); // 计算文件的 MD5 哈希值
  114.     PrintHex(hash1); // 输出文件的哈希值
  115.  
  116.     for (;;) { // 无限循环
  117.         auto hash = GetFileListHash(filepath); // 重新计算文件哈希值
  118.         auto thash = GetFileMerkleHash(filepath); // 计算文件的 Merkle 哈希值
  119.  
  120.         if (hash != hash1) { // 如果文件哈希值与之前的哈希不相等
  121.             cout << "文件被修改" << endl; // 输出文件被修改的警告
  122.             cout << "HashList:\t"; // 输出哈希列表的提示
  123.             PrintHex(hash); // 输出新的哈希值
  124.             hash1 = hash; // 更新之前的哈希值
  125.  
  126.             cout << "MerkleTree:\t"; // 输出 Merkle 树的提示
  127.             PrintHex(thash); // 输出 Merkle 哈希值
  128.         }
  129.         this_thread::sleep_for(chrono::seconds(1)); // 每秒检查一次
  130.     }
  131.  
  132.     return 0; // 程序正常结束
  133. }

makefile

  1. first_openss:test_openssl.cpp
  2. 	g++ $^ -o $@ -I/usr/local/include -L/usr/local/lib -lcrypto -std=c++11

1.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 位，即填充后的消息长度为 声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】

推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。