13年前に書いたrubyでsha-256を計算するスクリプトを発掘

仕様に近い形でソースを書けてた。ruby3.0は少し速くなってるね。Digest::SHA256を使えない環境でも動く。固定長のビット演算モジュールがあればもっと高速に計算できるはず。

# -*- encoding: US-ASCII -*-
# SHA-256 implementation of pure ruby.

module Purerubysha256
  MASK = 0xffffffff
  def self.rotr(i, n)
    (i >> n) | (MASK & (i << (32 - n)))
  end

  def self.inttostr(i)
    sprintf("%08X", i)
  end

  def self.digest(str)
    [hexdigest(str)].pack("H*")
  end

  def self.hexdigest(str)
    #H[0]..H[7]
    h_a = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
           0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
    # ch(x, y, z) = (x and y) xor (not x and z)
    ch = lambda {|x, y, z| (x & y) ^ (~x & z)}
    # Maj(x, y, z) = (x and y) xor (x and z) xor (y and z)
    maj = lambda {|x, y, z| (x & y) ^ (x & z) ^ (y & z)}
    # s ss
    s0 = lambda {|x| rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22)}
    s1 = lambda {|x| rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25)}
    ss0 = lambda {|x| rotr(x, 7) ^ rotr(x, 18) ^ (x >> 3)}
    ss1 = lambda {|x| rotr(x, 17) ^ rotr(x, 19) ^ (x >> 10)}

    # K[0]..K[63]
    k_a = [
      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,
    ]

    # "1" is appended.
    buf = str + ["10000000"].pack("B8")

    if (56 - buf.size % 64) < 0
      (64 + (56 - buf.size % 64)).times do
        buf += [0].pack("C")
      end
    else
      (56 - buf.size % 64).times do
        buf += [0].pack("C")
      end
    end

    # set the number of bits in the original message.
    buf += [sprintf("%016X", str.size * 8)].pack("H*")

    m_a = []
    (buf.size / 64).times do |i|
      m_a[i] = buf[i * 64, 64]
    end

    m_a.each do |m|
      w = []
      # W0 to W15
      w = m.unpack("N16")

      # W16 to W63
      (16..63).each do |t|
        # W(t) = ss1(W(t - 2)) + W(t - 7) + ss0(W(t - 15)) + W(t - 16)
        w[t] = MASK & (ss1.call(w[t - 2]) + w[t - 7] + ss0.call(w[t - 15]) + w[t - 16])
      end

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

      64.times do |t|
        # T1 = h + s1(e) + ch(e,f,g) + K(t) + W(t)
        t1 = MASK & (h + s1.call(e) + ch.call(e, f, g) + k_a[t] + w[t])
        # T2 = s0(a) + maj(a,b,c)
        t2 = MASK & (s0.call(a) + maj.call(a, b, c))
        # h = g, g = f, f = e, e = d + T1, d = c, c = b, b = a, a = T1 + T2
        h = g
        g = f
        f = e
        e = MASK & (d + t1)
        d = c
        c = b
        b = a
        a = MASK & (t1 + t2)
      end

      # H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E
      h_a[0] = MASK & (h_a[0] + a)
      h_a[1] = MASK & (h_a[1] + b)
      h_a[2] = MASK & (h_a[2] + c)
      h_a[3] = MASK & (h_a[3] + d)
      h_a[4] = MASK & (h_a[4] + e)
      h_a[5] = MASK & (h_a[5] + f)
      h_a[6] = MASK & (h_a[6] + g)
      h_a[7] = MASK & (h_a[7] + h)
    end

    str = ""
    h_a.each do |v|
      str << inttostr(v)
    end
    str
  end
end

require 'benchmark'
require 'digest/sha2'

Benchmark.bm do |x|
p "abc"
  x.report { p Purerubysha256.hexdigest("abc") }
  x.report { p Digest::SHA256.hexdigest("abc") }
p "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
p ""
p "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  x.report { p Purerubysha256.hexdigest("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") }
  x.report { p Digest::SHA256.hexdigest("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") }
p "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"
p ""
p "a * 1000000"
buf = "a" * 1000000
  x.report { p Purerubysha256.hexdigest(buf) }
  x.report { p Digest::SHA256.hexdigest(buf) }
p "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0"
end