SHA-256的双分部分的十六进制表示

我正在尝试编写sha-256哈希函数以进行练习。在Wikipedia中，初始哈希值由前8个素数2..19的平方根的分数给出。现在，我正在尝试计算它们。到目前为止，我已经做了什么：

#include <vector>
#include <cstdint>
#include <cmath>
#include <cstdio>
// fill primes with all prime values between min and max value
int getPrimes(uint32_t min, uint32_t max, std::vector<uint32_t>* primes)
{
  if (min < 1) min = 1;     // primes can only be >= 1
  if (min > max) return 0;  // max has to be larger than min

  for (uint32_t value = min; value <= max; value++)
  {
    uint32_t tmp;
    for (tmp = 2; tmp <= sqrt(value); tmp++)  // start to check with 2, because 1 is always going to work
    {
      if (value % tmp == 0)
      {
        break;
      }
    }
    if (tmp > sqrt(value)) primes->push_back(value);   // if no other integer divisor is found, add number to vector
  }
  return 0;
}
int main()
{
  std::vector<uint32_t> primes;
  getPrimes(2, 20, &primes);  // fills vector with all prime values between 2 and 20
  double tmp = sqrt(primes[0]);                       // get square root, returns double
  printf("value %fn", tmp);                          // debug
  printf("size of double %in", sizeof(double));      // get representation byte size
  double * tmpOffset = &tmp;                          // get value offset
  unsigned char   * tmpChar   = (unsigned char*)tmpOffset;              // convert to char pointer
  printf("address of variable %in", &tmp);           // debug
  printf("raw valuesn1:%Xn2:%Xn3:%Xn4:%Xn5:%Xn6:%Xn7:%Xn8:%Xn",
         (uint8_t)tmpChar[0], (uint8_t)tmpChar[1], (uint8_t)tmpChar[2], (uint8_t)tmpChar[3],
         (uint8_t)tmpChar[4], (uint8_t)tmpChar[5], (uint8_t)tmpChar[6], (uint8_t)tmpChar[7]);

  return 0;
}

这返回前8个素数，计算2的平方根，并直接从存储实际字节值的内存位置获取：

value 1.414214
size of double 8
address of variable 6881016
raw values
1:CD
2:3B
3:7F
4:66
5:9E
6:A0
7:F6
8:3F

与Wikipedia文章0x6a09e667中给出的价值相比，我在这里做的事很大。是否发生重新映射或双重二进制重新启动？

编辑：感谢您的帮助！它不是很漂亮，但现在可以工作。

  printf("raw fractional part:n0x%02X %02X %02X %02X %02X %02X %02Xn",
         (uint8_t)(0xf & tmpChar[6]), (uint8_t)tmpChar[5], (uint8_t)tmpChar[4], (uint8_t)tmpChar[3],
         (uint8_t)tmpChar[2], (uint8_t)tmpChar[1], (uint8_t)tmpChar[0]);

  uint32_t fracPart = (0xf & tmpChar[6]);
  fracPart <<= 8;
  fracPart |= tmpChar[5];
  fracPart <<= 8;
  fracPart |= tmpChar[4] ;
  fracPart <<= 8;
  fracPart |= tmpChar[3];
  fracPart <<= 4;
  fracPart |= (0xf0 & tmpChar[2]) >> 4;
  printf("fractional part: %Xn", fracPart);

edit2 更好的实现：

  uint32_t fracPart2 = *(uint32_t*)((char*)&tmp + 3);     // point to fractional part - 4 bit
  fracPart2 <<= 4;                                        // shift to correct value
  fracPart2 |= (0xf0 & *((char*)&tmp + 2)) >> 4;          // append last 4 bit
  printf("beautiful fractional part: %Xn", fracPart2);

此解决方案高度依赖于平台，在第二种方法中，我要在评论2的链接中进行类似的内容。

edit3

因此，这是我的最终解决方案，它不取决于双重的内部表示，并仅使用数学计算分数。

uint32_t getFractionalPart(double value)
{
  uint32_t retValue = 0;
  for (uint8_t i = 0; i < 8; i++)
  {
    value = value - floor(value);
    retValue <<= 4;
    value *= 16;
    retValue += floor(value);
  }
  return retValue;
}