实验八  SHA-2

1.实验目的

熟悉SHA – 2算法的运行过程，能够使用C++语言编写实现SHA-2算法程序，增加对摘要函数的理解。

2、实验任务

（1）理解SHA-2轮函数的定义和常量的定义。

（2）利用VC++语言实现SHA-2算法。

（3）分析SHA-2算法运行的性能。

3、实验原理

SHA-256算法输入报文的最大长度不超过2“比特，输入按512比特分组进行处理，产生的输出是一个256比特的报文摘要。该算法处理包括以下几步:

(1）附加填充比特。对报文进行填充使报文长度与448模512同余(长度=448 mod512)，填充的比特数范围是1～512，填充比特串的最高位为l，其余位为0。

(2）附加长度值。将用64比特表示的初始报文(填充前)的位长度附加在步骤1的结果后(低位字节优先)。

(3）初始化缓存。使用一个256比特的缓存来存放该散列函数的中间及最终结果。该缓存表示为A=0x6A09E667，B=0xBB67AE85，C=Оx3C6EF372，D=0xA54FF53A，E=0x510E527F，F=0x9B05688C，G=0xlF83D9AB，H=0x5BEOCD19。

(4）处理512比特(16个字)报文分组序列。该算法使用了六种基本逻辑函数，由64步迭代运算组成。每步都以256比特缓存值ABCDEFGH为输入，然后更新缓存内容。每步使用一个32比特常数值Kt和一个32比特Wt。

4、实验过程

SHA-2是一组密码学哈希函数，包括SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224和SHA-512/256。SHA-2轮函数定义了SHA-2算法中的核心操作。SHA-2算法使用了不同的轮函数，具体取决于哈希函数的变种。SHA-256的轮函数包括以下步骤：

 a. 消息预处理：原始消息被填充为512位的多个块。然后，消息长度被附加到消息的末尾，通常以64位的二进制表示。

b. 初始化Hash值：SHA-256使用8个32位的初始化Hash值（A, B, C, D, E, F, G, H），这些值是根据黄金分割数来确定的，通常使用前256位的平方根的小数部分的前32位。

c. 消息分块：原始消息被分成512位的块，依次处理。

d. 消息调度：512位块被分成16个32位的字，然后根据一定规则，生成额外的字（W[16]到W[63]），用于轮函数的迭代。

e. 轮函数迭代：SHA-256算法包括64轮迭代，每轮使用不同的常量K和轮函数，对Hash值进行更新。

f. 生成哈希值：最后，合并所有Hash值（A, B, C, D, E, F, G, H）并输出。

SHA-2常量K是每轮中使用的常量值，每个常量K的值是SHA-256算法中的一个根号数的小数部分的前32位。这些常量K的值在SHA-256算法中是固定的。

#include <iostream>
#include <iomanip>
#include <string>
#include <cstring>
#include <sstream>
#include <vector>
#include <cstdint>

// SHA-256 Constants
const uint32_t K[] = {
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};

#define ROTR(x, n) ((x >> n) | (x << (32 - n)))
#define SHR(x, n) (x >> n)


uint32_t Ch(uint32_t x, uint32_t y, uint32_t z) {
    return (x & y) ^ (~x & z);
}

uint32_t Maj(uint32_t x, uint32_t y, uint32_t z) {
    return (x & y) ^ (x & z) ^ (y & z);
}

uint32_t Sigma0(uint32_t x) {
    return ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22);
}

uint32_t Sigma1(uint32_t x) {
    return ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25);
}

uint32_t sigma0(uint32_t x) {
    return ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3);
}

uint32_t sigma1(uint32_t x) {
    return ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10);
}

// SHA-256 
void sha2(const std::string &message) {
    std::vector<uint8_t> data(message.begin(), message.end());

    
    uint64_t messageLength = data.size() * 8;
    data.push_back(0x80); 
    while ((data.size() + 8) % 64 != 0) {
        data.push_back(0x00);
    }


    for (int i = 0; i < 8; ++i) {
        data.push_back((messageLength >> (56 - i * 8)) & 0xFF);
    }


    uint32_t h[8] = {
        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
    };


    for (size_t i = 0; i < data.size(); i += 64) {
        uint32_t w[64];
        for (int t = 0; t < 16; ++t) {
            w[t] = (data[i + t * 4] << 24) | (data[i + t * 4 + 1] << 16) | (data[i + t * 4 + 2] << 8) | data[i + t * 4 + 3];
        }
        for (int t = 16; t < 64; ++t) {
            w[t] = sigma1(w[t - 2]) + w[t - 7] + sigma0(w[t - 15]) + w[t - 16];
        }

        uint32_t a = h[0];
        uint32_t b = h[1];
        uint32_t c = h[2];
        uint32_t d = h[3];
        uint32_t e = h[4];
        uint32_t f = h[5];
        uint32_t g = h[6];
        uint32_t j = h[7];

        for (int t = 0; t < 64; ++t) {
            uint32_t t1 = j + Sigma1(e) + Ch(e, f, g) + K[t] + w[t];
            uint32_t t2 = Sigma0(a) + Maj(a, b, c);
            j = g;
            g = f;
            f = e;
            e = d + t1;
            d = c;
            c = b;
            b = a;
            a = t1 + t2;
        }

        h[0] += a;
        h[1] += b;
        h[2] += c;
        h[3] += d;
        h[4] += e;
        h[5] += f;
        h[6] += g;
        h[7] += j;
    }


    for (int i = 0; i < 8; ++i) {
        std::cout << std::hex << std::setfill('0') << std::setw(8) << h[i];
    }
    std::cout << std::dec << std::endl;
}

int main() {
    std::string message = "Hello, SHA-2!";
    sha2(message);
    return 0;
}

5、实验心得

        SHA-2算法是一种广泛使用的密码学哈希函数，用于计算数据的消息摘要。SHA-2包括一系列不同长度的哈希函数，如SHA-224、SHA-256、SHA-384和SHA-512，分别输出224位、256位、384位和512位的消息摘要。本次实验采用SHA-256实现算法，SHA-2算法是一种强大的哈希算法，通常用于数据完整性验证、数字签名等应用。