【C言語】ビットコインとイーサリアムで利用する暗号学的ハッシュ関数【SHA-2，SHA-3/Keccak】

悩んでいる人

C言語でビットコインとイーサリアムで利用する暗号学的ハッシュ関数を教えて！

こういった悩みにお答えします．

本記事の信頼性

リアルタイムシステムの研究歴12年．
東大教員の時に，英語でOS（Linuxカーネル）の授業．
2012年9月～2013年8月にアメリカのノースカロライナ大学チャペルヒル校（UNC）コンピュータサイエンス学部で客員研究員として勤務．C言語でリアルタイムLinuxの研究開発．
プログラミング歴15年以上，習得している言語: C/C++，Python，Solidity/Vyper，Java，Ruby，Go，Rust，D，HTML/CSS/JS/PHP，MATLAB，Verse（UEFN）, Assembler (x64，ARM)．
東大教員の時に，C++言語で開発した「LLVMコンパイラの拡張」，C言語で開発した独自のリアルタイムOS「Mcube Kernel」をGitHubにオープンソースとして公開．
2020年1月～現在はアメリカのノースカロライナ州チャペルヒルにあるGuarantee Happiness LLCのCTOとしてECサイト開発やWeb/SNSマーケティングの業務．2022年6月～現在はアメリカのノースカロライナ州チャペルヒルにあるJapanese Tar Heel, Inc.のCEO兼CTO．
最近は自然言語処理AIとイーサリアムに関する有益な情報発信に従事．

（AI全般を含む）自然言語処理AIの論文の日本語訳や，AIチャットボット（ChatGPT，Auto-GPT，Gemini（旧Bard）など）の記事を50本以上執筆．アメリカのサンフランシスコ（広義のシリコンバレー）の会社でプロンプトエンジニア・マネージャー・Quality Assurance（QA）の業務委託の経験あり．
（スマートコントラクトのプログラミングを含む）イーサリアムや仮想通貨全般の記事を200本以上執筆．イギリスのロンドンの会社で仮想通貨の英語の記事を日本語に翻訳する業務委託の経験あり．

こういった私から学べます．

C言語を独学で習得することは難しいです．

私にC言語の無料相談をしたいあなたは，公式LINE「ChishiroのC言語」の友だち追加をお願い致します．

私のキャパシティもあり，一定数に達したら終了しますので，今すぐ追加しましょう！

独学が難しいあなたは，元東大教員がおすすめするC言語を学べるオンラインプログラミングスクール5社で自分に合うスクールを見つけましょう．後悔はさせません！

: 元東大教員がおすすめするC言語を学べるオンラインプログラミングスクール5社

こういった悩みにお答えします．こういった私が解説していきます．私が大学の授業で初めてC言語を勉強した時は全然できませんでしたが，先生やTA，友人に相談しながら一生懸命C言語を勉強してできるようにな ...

続きを見る

ビットコインとイーサリアムで利用する暗号学的ハッシュ関数

ビットコインとイーサリアムで利用する暗号学的ハッシュ関数を紹介します．

具体的には，SHA-2とSHA-3/Keccakを解説します．

SHA-2（SHA-256）【ビットコインで利用】

SHA-2は，SHA-1を改良版した暗号学的ハッシュ関数です．

※SHA-1はSHA-0の脆弱性を改良した暗号学的ハッシュ関数です．

SHA-2の出力長が256ビットのものとして，SHA-256があります．

ビットコインは，SHA-256を利用しています．

ビットコインを知りたいあなたはこちらからどうぞ．

: ビットコイン（Bitcoin）とは【買い方】【仮想通貨のパイオニア】

こういった悩みにお答えします．こういった私から学べます．ビットコイン（Bitcoin）ビットコイン（Bitcoin）とは，ピアツーピア（P2P：Peer-to-Peer）のビットコインネットワー ...

続きを見る

SHA-3/Keccak（SHA3-256/Keccak-256）【イーサリアムで利用】

SHA-3/Keccakは，SHA-2の代替として開発された暗号学的ハッシュ関数です．

SHA-3/Keccakの出力長が256ビットのものとして，SHA3-256とKeccak-256があります．

SHA3-256とKeccak-256の違いは，後処理でのパディングルールのみです．

SHA3-256とKeccak-256の前処理と本処理は同じアルゴリズムになります．

本処理が終わった後に実行する後処理でパディングする処理が異なります．

C言語では，SHA3-256とKeccak-256の違いを，たった一行で表現できます．

イーサリアムでは，Keccak-256を利用しています．

イーサリアムを知りたいあなたはこちらからどうぞ．

: 元東大教員/アメリカ企業CEO兼CTOから学ぶイーサリアム（Ethereum）

こういった私から学べます．元東大教員/アメリカ企業CEO兼CTOの私が，イーサリアム（Ethereum）について解説します．イーサリアムで取引，NFTの売買，ゲーム，プログラミングをしたいあなたに ...

続きを見る

SHA2（SHA-256）のコード

SHA2（SHA-256）のコードは以下になります．

/*
 * Author: Hiroyuki Chishiro
 * License: 2-Clause BSD
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#define SHA2_HASH_SIZE 32
#define SHA2_CHUNK_SIZE 64

struct sha2 {
  uint8_t *hash;
  uint8_t chunk[SHA2_CHUNK_SIZE];
  uint8_t *chunk_pos;
  size_t space_left;
  size_t total_len;
  uint32_t h[8];
};

#define TOTAL_LEN 8
#define BUFSIZE 128

static 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
};

uint32_t right_rot(uint32_t value, unsigned int count)
{
  return (value >> count) | (value << (32 - count));
}

void consume_chunk(uint32_t *h, const uint8_t *p)
{
  int i, j;
  uint32_t ah[8];
  uint32_t w[16];
  uint32_t s0, s1, ch, tmp, tmp2, maj;

  for (i = 0; i < 8; i++) {
    ah[i] = h[i];
  }

  for (i = 0; i < 4; i++) {
    for (j = 0; j < 16; j++) {
      if (i == 0) {
        w[j] = ((uint32_t) p[0] << 24) | ((uint32_t) p[1] << 16)
               | ((uint32_t) p[2] << 8) | ((uint32_t) p[3]);
        p += 4;
      } else {
        s0 = right_rot(w[(j + 1) & 0xf], 7) ^ right_rot(w[(j + 1) & 0xf], 18) ^
             (w[(j + 1) & 0xf] >> 3);
        s1 = right_rot(w[(j + 14) & 0xf], 17) ^ right_rot(w[(j + 14) & 0xf], 19) ^
             (w[(j + 14) & 0xf] >> 10);
        w[j] = w[j] + s0 + w[(j + 9) & 0xf] + s1;
      }

      s1 = right_rot(ah[4], 6) ^ right_rot(ah[4], 11) ^ right_rot(ah[4], 25);
      ch = (ah[4] & ah[5]) ^ (~ah[4] & ah[6]);

      tmp = ah[7] + s1 + ch + k[i << 4 | j] + w[j];
      s0 = right_rot(ah[0], 2) ^ right_rot(ah[0], 13) ^ right_rot(ah[0], 22);
      maj = (ah[0] & ah[1]) ^ (ah[0] & ah[2]) ^ (ah[1] & ah[2]);
      tmp2 = s0 + maj;

      ah[7] = ah[6];
      ah[6] = ah[5];
      ah[5] = ah[4];
      ah[4] = ah[3] + tmp;
      ah[3] = ah[2];
      ah[2] = ah[1];
      ah[1] = ah[0];
      ah[0] = tmp + tmp2;
    }
  }

  for (i = 0; i < 8; i++) {
    h[i] += ah[i];
  }
}

void sha2_init(struct sha2 *sha2, uint8_t hash[SHA2_HASH_SIZE])
{
  sha2->hash = hash;
  sha2->chunk_pos = sha2->chunk;
  sha2->space_left = SHA2_CHUNK_SIZE;
  sha2->total_len = 0;
  sha2->h[0] = 0x6a09e667;
  sha2->h[1] = 0xbb67ae85;
  sha2->h[2] = 0x3c6ef372;
  sha2->h[3] = 0xa54ff53a;
  sha2->h[4] = 0x510e527f;
  sha2->h[5] = 0x9b05688c;
  sha2->h[6] = 0x1f83d9ab;
  sha2->h[7] = 0x5be0cd19;
}

void sha2_write(struct sha2 *sha2, const void *data, size_t len)
{
  size_t consumed_len;
  const uint8_t *p = data;
  sha2->total_len += len;

  while (len > 0) {
    if (sha2->space_left == SHA2_CHUNK_SIZE &&
        len >= SHA2_CHUNK_SIZE) {
      consume_chunk(sha2->h, p);
      len -= SHA2_CHUNK_SIZE;
      p += SHA2_CHUNK_SIZE;
      continue;
    }

    consumed_len = len < sha2->space_left ? len : sha2->space_left;
    memcpy(sha2->chunk_pos, p, consumed_len);
    sha2->space_left -= consumed_len;
    len -= consumed_len;
    p += consumed_len;

    if (sha2->space_left == 0) {
      consume_chunk(sha2->h, sha2->chunk);
      sha2->chunk_pos = sha2->chunk;
      sha2->space_left = SHA2_CHUNK_SIZE;
    } else {
      sha2->chunk_pos += consumed_len;
    }
  }
}

uint8_t *sha2_exit(struct sha2 *sha2)
{
  uint8_t *pos = sha2->chunk_pos;
  size_t space_left = sha2->space_left;
  uint32_t *const h = sha2->h;
  size_t left;
  size_t len;
  int i, j;
  uint8_t *hash;

  *pos++ = 0x80;
  space_left--;

  if (space_left < TOTAL_LEN) {
    memset(pos, 0x00, space_left);
    consume_chunk(h, sha2->chunk);
    pos = sha2->chunk;
    space_left = SHA2_CHUNK_SIZE;
  }

  left = space_left - TOTAL_LEN;
  memset(pos, 0x00, left);
  pos += left;
  len = sha2->total_len;
  pos[7] = (uint8_t)(len << 3);
  len >>= 5;

  for (i = 6; i >= 0; i--) {
    pos[i] = (uint8_t)len;
    len >>= 8;
  }

  consume_chunk(h, sha2->chunk);
  hash = sha2->hash;

  for (i = 0, j = 0; i < 8; i++) {
    hash[j++] = (uint8_t)(h[i] >> 24);
    hash[j++] = (uint8_t)(h[i] >> 16);
    hash[j++] = (uint8_t)(h[i] >> 8);
    hash[j++] = (uint8_t)h[i];
  }

  return sha2->hash;
}

void hash_to_string(char string[], const uint8_t hash[SHA2_HASH_SIZE])
{
  size_t i;

  for (i = 0; i < SHA2_HASH_SIZE; i++) {
    string += sprintf(string, "%02x", hash[i]);
  }
}

void do_sha2(char hash_string[], const char input[])
{
  uint8_t hash[SHA2_HASH_SIZE];
  struct sha2 sha2;
  size_t len = strlen(input);

  sha2_init(&sha2, hash);
  sha2_write(&sha2, input, len);
  sha2_exit(&sha2);
  hash_to_string(hash_string, hash);
}

int main(void)
{
  char buf[BUFSIZE];
  char hash_string[BUFSIZE];
  size_t len;

  printf("Please input a string: ");
  fgets(buf, SHA2_HASH_SIZE, stdin);
  len = strlen(buf) - 1;
  buf[len] = '\0';
  printf("buf = %s\n", buf);

  do_sha2(hash_string, buf);
  printf("SHA-256: %s\n", hash_string);

  return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

* Author: Hiroyuki Chishiro

* License: 2-Clause BSD

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include <string.h>

#define SHA2_HASH_SIZE 32

#define SHA2_CHUNK_SIZE 64

struct sha2 {

uint8_t *hash;

uint8_t chunk[SHA2_CHUNK_SIZE];

uint8_t *chunk_pos;

size_t space_left;

size_t total_len;

uint32_t h[8];

};

#define TOTAL_LEN 8

#define BUFSIZE 128

static 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

};

uint32_t right_rot(uint32_t value, unsigned int count)

{

return (value >> count) | (value << (32 - count));

}

void consume_chunk(uint32_t *h, const uint8_t *p)

{

int i, j;

uint32_t ah[8];

uint32_t w[16];

uint32_t s0, s1, ch, tmp, tmp2, maj;

for (i = 0; i < 8; i++) {

ah[i] = h[i];

}

for (i = 0; i < 4; i++) {

for (j = 0; j < 16; j++) {

if (i == 0) {

w[j] = ((uint32_t) p[0] << 24) | ((uint32_t) p[1] << 16)

| ((uint32_t) p[2] << 8) | ((uint32_t) p[3]);

p += 4;

} else {

s0 = right_rot(w[(j + 1) & 0xf], 7) ^ right_rot(w[(j + 1) & 0xf], 18) ^

(w[(j + 1) & 0xf] >> 3);

s1 = right_rot(w[(j + 14) & 0xf], 17) ^ right_rot(w[(j + 14) & 0xf], 19) ^

(w[(j + 14) & 0xf] >> 10);

w[j] = w[j] + s0 + w[(j + 9) & 0xf] + s1;

}

s1 = right_rot(ah[4], 6) ^ right_rot(ah[4], 11) ^ right_rot(ah[4], 25);

ch = (ah[4] & ah[5]) ^ (~ah[4] & ah[6]);

tmp = ah[7] + s1 + ch + k[i << 4 | j] + w[j];

s0 = right_rot(ah[0], 2) ^ right_rot(ah[0], 13) ^ right_rot(ah[0], 22);

maj = (ah[0] & ah[1]) ^ (ah[0] & ah[2]) ^ (ah[1] & ah[2]);

tmp2 = s0 + maj;

ah[7] = ah[6];

ah[6] = ah[5];

ah[5] = ah[4];

ah[4] = ah[3] + tmp;

ah[3] = ah[2];

ah[2] = ah[1];

ah[1] = ah[0];

ah[0] = tmp + tmp2;

}

for (i = 0; i < 8; i++) {

h[i] += ah[i];

}

void sha2_init(struct sha2 *sha2, uint8_t hash[SHA2_HASH_SIZE])

{

sha2->hash = hash;

sha2->chunk_pos = sha2->chunk;

sha2->space_left = SHA2_CHUNK_SIZE;

sha2->total_len = 0;

sha2->h[0] = 0x6a09e667;

sha2->h[1] = 0xbb67ae85;

sha2->h[2] = 0x3c6ef372;

sha2->h[3] = 0xa54ff53a;

sha2->h[4] = 0x510e527f;

sha2->h[5] = 0x9b05688c;

sha2->h[6] = 0x1f83d9ab;

sha2->h[7] = 0x5be0cd19;

}

void sha2_write(struct sha2 *sha2, const void *data, size_t len)

{

size_t consumed_len;

const uint8_t *p = data;

sha2->total_len += len;

while (len > 0) {

if (sha2->space_left == SHA2_CHUNK_SIZE &&

len >= SHA2_CHUNK_SIZE) {

consume_chunk(sha2->h, p);

len -= SHA2_CHUNK_SIZE;

p += SHA2_CHUNK_SIZE;

continue;

}

consumed_len = len < sha2->space_left ? len : sha2->space_left;

memcpy(sha2->chunk_pos, p, consumed_len);

sha2->space_left -= consumed_len;

len -= consumed_len;

p += consumed_len;

if (sha2->space_left == 0) {

consume_chunk(sha2->h, sha2->chunk);

sha2->chunk_pos = sha2->chunk;

sha2->space_left = SHA2_CHUNK_SIZE;

} else {

sha2->chunk_pos += consumed_len;

}

uint8_t *sha2_exit(struct sha2 *sha2)

{

uint8_t *pos = sha2->chunk_pos;

size_t space_left = sha2->space_left;

uint32_t *const h = sha2->h;

size_t left;

size_t len;

int i, j;

uint8_t *hash;

*pos++ = 0x80;

space_left--;

if (space_left < TOTAL_LEN) {

memset(pos, 0x00, space_left);

consume_chunk(h, sha2->chunk);

pos = sha2->chunk;

space_left = SHA2_CHUNK_SIZE;

}

left = space_left - TOTAL_LEN;

memset(pos, 0x00, left);

pos += left;

len = sha2->total_len;

pos[7] = (uint8_t)(len << 3);

len >>= 5;

for (i = 6; i >= 0; i--) {

pos[i] = (uint8_t)len;

len >>= 8;

}

consume_chunk(h, sha2->chunk);

hash = sha2->hash;

for (i = 0, j = 0; i < 8; i++) {

hash[j++] = (uint8_t)(h[i] >> 24);

hash[j++] = (uint8_t)(h[i] >> 16);

hash[j++] = (uint8_t)(h[i] >> 8);

hash[j++] = (uint8_t)h[i];

}

return sha2->hash;

}

void hash_to_string(char string[], const uint8_t hash[SHA2_HASH_SIZE])

{

size_t i;

for (i = 0; i < SHA2_HASH_SIZE; i++) {

string += sprintf(string, "%02x", hash[i]);

}

void do_sha2(char hash_string[], const char input[])

{

uint8_t hash[SHA2_HASH_SIZE];

struct sha2 sha2;

size_t len = strlen(input);

sha2_init(&sha2, hash);

sha2_write(&sha2, input, len);

sha2_exit(&sha2);

hash_to_string(hash_string, hash);

}

int main(void)

{

char buf[BUFSIZE];

char hash_string[BUFSIZE];

size_t len;

printf("Please input a string: ");

fgets(buf, SHA2_HASH_SIZE, stdin);

len = strlen(buf) - 1;

buf[len] = '\0';

printf("buf = %s\n", buf);

do_sha2(hash_string, buf);

printf("SHA-256: %s\n", hash_string);

return 0;

}

空の文字列を入力した場合の実行結果は以下になります．

こちらのツールで同じ結果「e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855」になることを確認しましょう．

$ gcc sha2.c
$ a.out 
Please input a string: 
buf = 
SHA-256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

$ gcc sha2.c

$ a.out

Please input a string:

buf =

SHA-256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

SHA3-256とKeccak-256のコード

SHA3-256とKeccak-256のコードは以下になります．

SHA3-256とKeccak-256の前処理と後処理は同様の結果になります．

SHA3-256とKeccak-256の後処理の違いは，以下になります．

SHA3-256：192行目「t = (uint64_t)(((uint64_t)(0x02 | (1 << 2))) << ((ctx->byte_index) * 8));」
Keccak-256：190行目「t = (uint64_t)(((uint64_t) 0x01) << (ctx->byte_index * 8));」

このように，C言語では，たった1行で違いを表現できていることがわかります．

/*
 * Author: Hiroyuki Chishiro
 * License: 2-Clause BSD
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#define BUFSIZE 128
#define SHA3_HASH_SIZE 32

#define SHA3_KECCAK_SPONGE_WORDS ((1600 / 8) / sizeof(uint64_t))

struct sha3 {
  uint64_t saved;

  union {
    uint64_t s[SHA3_KECCAK_SPONGE_WORDS];
    uint8_t sb[SHA3_KECCAK_SPONGE_WORDS * (sizeof(uint64_t) / sizeof(uint8_t))];
  } u;
  uint32_t byte_index;
  uint32_t word_index;
  uint32_t capacity_words;
};

enum sha3_flags {
  SHA3_FLAGS_NONE = 0,
  SHA3_FLAGS_KECCAK = 1
};

#define SHA3_USE_KECCAK_FLAG 0x80000000
#define SHA3_CW(x) ((x) & (~SHA3_USE_KECCAK_FLAG))
#define SHA3_ROTL64(x, y) (((x) << (y)) | ((x) >> ((sizeof(uint64_t) * 8) - (y))))

#define KECCAK_ROUNDS 24

static const uint64_t keccakf_rndc[KECCAK_ROUNDS] = {
  0x0000000000000001UL, 0x0000000000008082UL,
  0x800000000000808aUL, 0x8000000080008000UL,
  0x000000000000808bUL, 0x0000000080000001UL,
  0x8000000080008081UL, 0x8000000000008009UL,
  0x000000000000008aUL, 0x0000000000000088UL,
  0x0000000080008009UL, 0x000000008000000aUL,
  0x000000008000808bUL, 0x800000000000008bUL,
  0x8000000000008089UL, 0x8000000000008003UL,
  0x8000000000008002UL, 0x8000000000000080UL,
  0x000000000000800aUL, 0x800000008000000aUL,
  0x8000000080008081UL, 0x8000000000008080UL,
  0x0000000080000001UL, 0x8000000080008008UL
};

static const uint32_t keccakf_rotc[KECCAK_ROUNDS] = {
  1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, 27, 41, 56, 8, 25, 43, 62,
  18, 39, 61, 20, 44
};

static const uint32_t keccakf_piln[KECCAK_ROUNDS] = {
  10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, 15, 23, 19, 13, 12, 2, 20,
  14, 22, 9, 6, 1
};

void keccak_block_permutation(uint64_t s[SHA3_KECCAK_SPONGE_WORDS])
{
  int i, j, round;
  uint64_t t, bc[5];

  for (round = 0; round < KECCAK_ROUNDS; round++) {
    for (i = 0; i < 5; i++) {
      bc[i] = s[i] ^ s[i + 5] ^ s[i + 10] ^ s[i + 15] ^ s[i + 20];
    }

    for (i = 0; i < 5; i++) {
      t = bc[(i + 4) % 5] ^ SHA3_ROTL64(bc[(i + 1) % 5], 1);

      for (j = 0; j < SHA3_KECCAK_SPONGE_WORDS; j += 5) {
        s[j + i] ^= t;
      }
    }

    t = s[1];

    for (i = 0; i < KECCAK_ROUNDS; i++) {
      j = keccakf_piln[i];
      bc[0] = s[j];
      s[j] = SHA3_ROTL64(t, keccakf_rotc[i]);
      t = bc[0];
    }

    for (j = 0; j < SHA3_KECCAK_SPONGE_WORDS; j += 5) {
      for (i = 0; i < 5; i++) {
        bc[i] = s[j + i];
      }

      for (i = 0; i < 5; i++) {
        s[j + i] ^= (~bc[(i + 1) % 5]) & bc[(i + 2) % 5];
      }
    }

    s[0] ^= keccakf_rndc[round];
  }
}

void sha3_init(void *priv)
{
  struct sha3 *ctx = (struct sha3 *) priv;

  memset(ctx, 0, sizeof(*ctx));
  ctx->capacity_words = (2 * SHA3_HASH_SIZE) / sizeof(uint64_t);
}

enum sha3_flags sha3_set_flags(void *priv, enum sha3_flags flags)
{
  struct sha3 *ctx = (struct sha3 *) priv;
  flags &= SHA3_FLAGS_KECCAK;
  ctx->capacity_words |= (flags == SHA3_FLAGS_KECCAK ? SHA3_USE_KECCAK_FLAG : 0);
  return flags;
}

void sha3_update(void *priv, void const *bufIn, size_t len)
{
  struct sha3 *ctx = (struct sha3 *) priv;
  uint32_t old_tail = (8 - ctx->byte_index) & 0x7;
  size_t words;
  uint32_t tail;
  size_t i;
  const uint8_t *buf = bufIn;
  uint64_t t;

  if (len < old_tail) {
    while (len--) {
      ctx->saved |= (uint64_t)(*(buf++)) << ((ctx->byte_index++) * 8);
    }

    return;
  }

  if (old_tail) {
    len -= old_tail;

    while (old_tail--) {
      ctx->saved |= (uint64_t)(*(buf++)) << ((ctx->byte_index++) * 8);
    }

    ctx->u.s[ctx->word_index] ^= ctx->saved;
    ctx->byte_index = 0;
    ctx->saved = 0;

    if (++ctx->word_index ==
        (SHA3_KECCAK_SPONGE_WORDS - SHA3_CW(ctx->capacity_words))) {
      keccak_block_permutation(ctx->u.s);
      ctx->word_index = 0;
    }
  }

  words = len / sizeof(uint64_t);
  tail = len - words * sizeof(uint64_t);

  for (i = 0; i < words; i++, buf += sizeof(uint64_t)) {
    t = (uint64_t)(buf[0]) |
        ((uint64_t)(buf[1]) << 8) |
        ((uint64_t)(buf[2]) << 16) |
        ((uint64_t)(buf[3]) << 24) |
        ((uint64_t)(buf[4]) << 32) |
        ((uint64_t)(buf[5]) << 40) |
        ((uint64_t)(buf[6]) << 48) |
        ((uint64_t)(buf[7]) << 56);
    ctx->u.s[ctx->word_index] ^= t;

    if (++ctx->word_index == SHA3_KECCAK_SPONGE_WORDS - SHA3_CW(
          ctx->capacity_words)) {
      keccak_block_permutation(ctx->u.s);
      ctx->word_index = 0;
    }
  }

  while (tail-- > 0) {
    ctx->saved |= (uint64_t)(*(buf++)) << ((ctx->byte_index++) * 8);
  }
}

void const *sha3_exit(void *priv)
{
  struct sha3 *ctx = (struct sha3 *) priv;
  uint64_t t;
  uint32_t t1, t2;
  int i;

  if (ctx->capacity_words & SHA3_USE_KECCAK_FLAG) {
    t = (uint64_t)(((uint64_t) 0x01) << (ctx->byte_index * 8));
  } else {
    t = (uint64_t)(((uint64_t)(0x02 | (1 << 2))) << ((ctx->byte_index) * 8));
  }

  ctx->u.s[ctx->word_index] ^= ctx->saved ^ t;

  ctx->u.s[SHA3_KECCAK_SPONGE_WORDS - SHA3_CW(ctx->capacity_words) - 1] ^=
    0x8000000000000000UL;
  keccak_block_permutation(ctx->u.s);


  for (i = 0; i < SHA3_KECCAK_SPONGE_WORDS; i++) {
    t1 = (uint32_t) ctx->u.s[i];
    t2 = (uint32_t)((ctx->u.s[i] >> 16) >> 16);
    ctx->u.sb[i * 8 + 0] = (uint8_t)(t1);
    ctx->u.sb[i * 8 + 1] = (uint8_t)(t1 >> 8);
    ctx->u.sb[i * 8 + 2] = (uint8_t)(t1 >> 16);
    ctx->u.sb[i * 8 + 3] = (uint8_t)(t1 >> 24);
    ctx->u.sb[i * 8 + 4] = (uint8_t)(t2);
    ctx->u.sb[i * 8 + 5] = (uint8_t)(t2 >> 8);
    ctx->u.sb[i * 8 + 6] = (uint8_t)(t2 >> 16);
    ctx->u.sb[i * 8 + 7] = (uint8_t)(t2 >> 24);
  }

  return ctx->u.sb;
}

void hash_to_string(char string[], const uint8_t hash[SHA3_HASH_SIZE])
{
  size_t i;

  for (i = 0; i < SHA3_HASH_SIZE; i++) {
    string += sprintf(string, "%02x", hash[i]);
  }
}

void do_sha3(enum sha3_flags flags, const void *in,
             uint32_t inBytes, void *out)
{
  struct sha3 c;
  const void *h;
  uint8_t hash[SHA3_HASH_SIZE];

  sha3_init(&c);

  if (sha3_set_flags(&c, flags) != flags) {
    fprintf(stderr, "Error: sha3_set_flags()\n");
    exit(1);
  }

  sha3_update(&c, in, inBytes);
  h = sha3_exit(&c);

  memcpy(hash, h, SHA3_HASH_SIZE);
  hash_to_string(out, hash);
}

int main(void)
{
  char buf[BUFSIZE], hash_string[BUFSIZE];
  size_t len;

  printf("Please input a string: ");
  fgets(buf, BUFSIZE, stdin);
  len = strlen(buf) - 1;
  buf[len] = '\0';
  printf("buf = %s\n", buf);

  strcpy(hash_string, buf);

  do_sha3(SHA3_FLAGS_NONE, hash_string, len, hash_string);
  printf("SHA3-256:   %s\n", hash_string);

  strcpy(hash_string, buf);
  do_sha3(SHA3_FLAGS_KECCAK, hash_string, len, hash_string);
  printf("Keccak-256: %s\n", hash_string);

  return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

* Author: Hiroyuki Chishiro

* License: 2-Clause BSD

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include <string.h>

#define BUFSIZE 128

#define SHA3_HASH_SIZE 32

#define SHA3_KECCAK_SPONGE_WORDS ((1600 / 8) / sizeof(uint64_t))

struct sha3 {

uint64_t saved;

union {

uint64_t s[SHA3_KECCAK_SPONGE_WORDS];

uint8_t sb[SHA3_KECCAK_SPONGE_WORDS * (sizeof(uint64_t) / sizeof(uint8_t))];

} u;

uint32_t byte_index;

uint32_t word_index;

uint32_t capacity_words;

};

enum sha3_flags {

SHA3_FLAGS_NONE = 0,

SHA3_FLAGS_KECCAK = 1

};

#define SHA3_USE_KECCAK_FLAG 0x80000000

#define SHA3_CW(x) ((x) & (~SHA3_USE_KECCAK_FLAG))

#define SHA3_ROTL64(x, y) (((x) << (y)) | ((x) >> ((sizeof(uint64_t) * 8) - (y))))

#define KECCAK_ROUNDS 24

static const uint64_t keccakf_rndc[KECCAK_ROUNDS] = {

0x0000000000000001UL, 0x0000000000008082UL,

0x800000000000808aUL, 0x8000000080008000UL,

0x000000000000808bUL, 0x0000000080000001UL,

0x8000000080008081UL, 0x8000000000008009UL,

0x000000000000008aUL, 0x0000000000000088UL,

0x0000000080008009UL, 0x000000008000000aUL,

0x000000008000808bUL, 0x800000000000008bUL,

0x8000000000008089UL, 0x8000000000008003UL,

0x8000000000008002UL, 0x8000000000000080UL,

0x000000000000800aUL, 0x800000008000000aUL,

0x8000000080008081UL, 0x8000000000008080UL,

0x0000000080000001UL, 0x8000000080008008UL

};

static const uint32_t keccakf_rotc[KECCAK_ROUNDS] = {

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, 27, 41, 56, 8, 25, 43, 62,

18, 39, 61, 20, 44

};

static const uint32_t keccakf_piln[KECCAK_ROUNDS] = {

10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, 15, 23, 19, 13, 12, 2, 20,

14, 22, 9, 6, 1

};

void keccak_block_permutation(uint64_t s[SHA3_KECCAK_SPONGE_WORDS])

{

int i, j, round;

uint64_t t, bc[5];

for (round = 0; round < KECCAK_ROUNDS; round++) {

for (i = 0; i < 5; i++) {

bc[i] = s[i] ^ s[i + 5] ^ s[i + 10] ^ s[i + 15] ^ s[i + 20];

}

for (i = 0; i < 5; i++) {

t = bc[(i + 4) % 5] ^ SHA3_ROTL64(bc[(i + 1) % 5], 1);

for (j = 0; j < SHA3_KECCAK_SPONGE_WORDS; j += 5) {

s[j + i] ^= t;

}

t = s[1];

for (i = 0; i < KECCAK_ROUNDS; i++) {

j = keccakf_piln[i];

bc[0] = s[j];

s[j] = SHA3_ROTL64(t, keccakf_rotc[i]);

t = bc[0];

}

for (j = 0; j < SHA3_KECCAK_SPONGE_WORDS; j += 5) {

for (i = 0; i < 5; i++) {

bc[i] = s[j + i];

}

for (i = 0; i < 5; i++) {

s[j + i] ^= (~bc[(i + 1) % 5]) & bc[(i + 2) % 5];

}

s[0] ^= keccakf_rndc[round];

}

void sha3_init(void *priv)

{

struct sha3 *ctx = (struct sha3 *) priv;

memset(ctx, 0, sizeof(*ctx));

ctx->capacity_words = (2 * SHA3_HASH_SIZE) / sizeof(uint64_t);

}

enum sha3_flags sha3_set_flags(void *priv, enum sha3_flags flags)

{

struct sha3 *ctx = (struct sha3 *) priv;

flags &= SHA3_FLAGS_KECCAK;

ctx->capacity_words |= (flags == SHA3_FLAGS_KECCAK ? SHA3_USE_KECCAK_FLAG : 0);

return flags;

}

void sha3_update(void *priv, void const *bufIn, size_t len)

{

struct sha3 *ctx = (struct sha3 *) priv;

uint32_t old_tail = (8 - ctx->byte_index) & 0x7;

size_t words;

uint32_t tail;

size_t i;

const uint8_t *buf = bufIn;

uint64_t t;

if (len < old_tail) {

while (len--) {

ctx->saved |= (uint64_t)(*(buf++)) << ((ctx->byte_index++) * 8);

}

return;

}

if (old_tail) {

len -= old_tail;

while (old_tail--) {

ctx->saved |= (uint64_t)(*(buf++)) << ((ctx->byte_index++) * 8);

}

ctx->u.s[ctx->word_index] ^= ctx->saved;

ctx->byte_index = 0;

ctx->saved = 0;

if (++ctx->word_index ==

(SHA3_KECCAK_SPONGE_WORDS - SHA3_CW(ctx->capacity_words))) {

keccak_block_permutation(ctx->u.s);

ctx->word_index = 0;

}

words = len / sizeof(uint64_t);

tail = len - words * sizeof(uint64_t);

for (i = 0; i < words; i++, buf += sizeof(uint64_t)) {

t = (uint64_t)(buf[0]) |

((uint64_t)(buf[1]) << 8) |

((uint64_t)(buf[2]) << 16) |

((uint64_t)(buf[3]) << 24) |

((uint64_t)(buf[4]) << 32) |

((uint64_t)(buf[5]) << 40) |

((uint64_t)(buf[6]) << 48) |

((uint64_t)(buf[7]) << 56);

ctx->u.s[ctx->word_index] ^= t;

if (++ctx->word_index == SHA3_KECCAK_SPONGE_WORDS - SHA3_CW(

ctx->capacity_words)) {

keccak_block_permutation(ctx->u.s);

ctx->word_index = 0;

}

while (tail-- > 0) {

ctx->saved |= (uint64_t)(*(buf++)) << ((ctx->byte_index++) * 8);

}

void const *sha3_exit(void *priv)

{

struct sha3 *ctx = (struct sha3 *) priv;

uint64_t t;

uint32_t t1, t2;

int i;

if (ctx->capacity_words & SHA3_USE_KECCAK_FLAG) {

t = (uint64_t)(((uint64_t) 0x01) << (ctx->byte_index * 8));

} else {

t = (uint64_t)(((uint64_t)(0x02 | (1 << 2))) << ((ctx->byte_index) * 8));

}

ctx->u.s[ctx->word_index] ^= ctx->saved ^ t;

ctx->u.s[SHA3_KECCAK_SPONGE_WORDS - SHA3_CW(ctx->capacity_words) - 1] ^=

0x8000000000000000UL;

keccak_block_permutation(ctx->u.s);

for (i = 0; i < SHA3_KECCAK_SPONGE_WORDS; i++) {

t1 = (uint32_t) ctx->u.s[i];

t2 = (uint32_t)((ctx->u.s[i] >> 16) >> 16);

ctx->u.sb[i * 8 + 0] = (uint8_t)(t1);

ctx->u.sb[i * 8 + 1] = (uint8_t)(t1 >> 8);

ctx->u.sb[i * 8 + 2] = (uint8_t)(t1 >> 16);

ctx->u.sb[i * 8 + 3] = (uint8_t)(t1 >> 24);

ctx->u.sb[i * 8 + 4] = (uint8_t)(t2);

ctx->u.sb[i * 8 + 5] = (uint8_t)(t2 >> 8);

ctx->u.sb[i * 8 + 6] = (uint8_t)(t2 >> 16);

ctx->u.sb[i * 8 + 7] = (uint8_t)(t2 >> 24);

}

return ctx->u.sb;

}

void hash_to_string(char string[], const uint8_t hash[SHA3_HASH_SIZE])

{

size_t i;

for (i = 0; i < SHA3_HASH_SIZE; i++) {

string += sprintf(string, "%02x", hash[i]);

}

void do_sha3(enum sha3_flags flags, const void *in,

uint32_t inBytes, void *out)

{

struct sha3 c;

const void *h;

uint8_t hash[SHA3_HASH_SIZE];

sha3_init(&c);

if (sha3_set_flags(&c, flags) != flags) {

fprintf(stderr, "Error: sha3_set_flags()\n");

exit(1);

}

sha3_update(&c, in, inBytes);

h = sha3_exit(&c);

memcpy(hash, h, SHA3_HASH_SIZE);

hash_to_string(out, hash);

}

int main(void)

{

char buf[BUFSIZE], hash_string[BUFSIZE];

size_t len;

printf("Please input a string: ");

fgets(buf, BUFSIZE, stdin);

len = strlen(buf) - 1;

buf[len] = '\0';

printf("buf = %s\n", buf);

strcpy(hash_string, buf);

do_sha3(SHA3_FLAGS_NONE, hash_string, len, hash_string);

printf("SHA3-256: %s\n", hash_string);

strcpy(hash_string, buf);

do_sha3(SHA3_FLAGS_KECCAK, hash_string, len, hash_string);

printf("Keccak-256: %s\n", hash_string);

return 0;

}

空の文字列を入力した場合の実行結果は以下になります．

$ gcc sha3_keccak.c
$ a.out 
Please input a string: 
buf = 
SHA3-256:   a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a
Keccak-256: c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470

$ gcc sha3_keccak.c

$ a.out

Please input a string:

buf =

SHA3-256: a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a

Keccak-256: c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470

以下のリンク先にあるツールで空の文字列を入力して暗号学的ハッシュ関数を実行すると同様の結果になることがわかります．

SHA3-256：a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a
Keccak-256：c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470

まとめ

C言語でビットコインとイーサリアムで利用する暗号学的ハッシュ関数を紹介しました．

ビットコインはSHA-2，イーサリアムはKeccakを利用していることがわかりました．

他の代表的な暗号学的ハッシュ関数としてBLAKEがありますので，興味があるあなたは以下のWebサイトで学びましょう！

2022年10月現在，BLAKE3（BLAKEのバージョン3）が最新版です．

C言語を独学で習得することは難しいです．

私にC言語の無料相談をしたいあなたは，公式LINE「ChishiroのC言語」の友だち追加をお願い致します．

私のキャパシティもあり，一定数に達したら終了しますので，今すぐ追加しましょう！

: 元東大教員がおすすめするC言語を学べるオンラインプログラミングスクール5社

こういった悩みにお答えします．こういった私が解説していきます．私が大学の授業で初めてC言語を勉強した時は全然できませんでしたが，先生やTA，友人に相談しながら一生懸命C言語を勉強してできるようにな ...

続きを見る

【C言語】ビットコインとイーサリアムで利用する暗号学的ハッシュ関数【SHA-2，SHA-3/Keccak】

元東大教員がおすすめするC言語を学べるオンラインプログラミングスクール5社

ビットコインとイーサリアムで利用する暗号学的ハッシュ関数

SHA-2（SHA-256）【ビットコインで利用】

ビットコイン（Bitcoin）とは【買い方】【仮想通貨のパイオニア】

SHA-3/Keccak（SHA3-256/Keccak-256）【イーサリアムで利用】

元東大教員/アメリカ企業CEO兼CTOから学ぶイーサリアム（Ethereum）

SHA2（SHA-256）のコード

SHA3-256とKeccak-256のコード

まとめ

元東大教員がおすすめするC言語を学べるオンラインプログラミングスクール5社